comparison dsp/onsets/DetectionFunction.cpp @ 227:f06672e8db10

* Make it possible to provide the detection function with frequency domain
  inputs (i.e. phase vocoder already run)

 //////////////////////////////////////////////////////////////////////
 
 DetectionFunction::DetectionFunction( DFConfig Config ) :
     m_window(0)
 {
-    magHistory = NULL;
-    phaseHistory = NULL;
-    phaseHistoryOld = NULL;
-    j = ComplexData( 0, 1 );
+    m_magHistory = NULL;
+    m_phaseHistory = NULL;
+    m_phaseHistoryOld = NULL;
 
     initialise( Config );
 }
 
 DetectionFunction::~DetectionFunction()

 {
     m_dataLength = Config.frameLength;
     m_halfLength = m_dataLength/2;
     m_DFType = Config.DFType;
 
-    magHistory = new double[ m_halfLength ];
-    memset(magHistory,0, m_halfLength*sizeof(double));
-		
-    phaseHistory = new double[ m_halfLength ];
-    memset(phaseHistory,0, m_halfLength*sizeof(double));
-
-    phaseHistoryOld = new double[ m_halfLength ];
-    memset(phaseHistoryOld,0, m_halfLength*sizeof(double));
+    m_magHistory = new double[ m_halfLength ];
+    memset(m_magHistory,0, m_halfLength*sizeof(double));
+		
+    m_phaseHistory = new double[ m_halfLength ];
+    memset(m_phaseHistory,0, m_halfLength*sizeof(double));
+
+    m_phaseHistoryOld = new double[ m_halfLength ];
+    memset(m_phaseHistoryOld,0, m_halfLength*sizeof(double));
 
     m_phaseVoc = new PhaseVocoder;
 
     m_DFWindowedFrame = new double[ m_dataLength ];
     m_magnitude = new double[ m_halfLength ];

     m_window = new Window<double>(HanningWindow, m_dataLength);
 }
 
 void DetectionFunction::deInitialise()
 {
-    delete [] magHistory ;
-    delete [] phaseHistory ;
-    delete [] phaseHistoryOld ;
+    delete [] m_magHistory ;
+    delete [] m_phaseHistory ;
+    delete [] m_phaseHistoryOld ;
 
     delete m_phaseVoc;
 
     delete [] m_DFWindowedFrame;
     delete [] m_magnitude;

     delete m_window;
 }
 
 double DetectionFunction::process( double *TDomain )
 {
+    m_window->cut( TDomain, m_DFWindowedFrame );
+	
+    m_phaseVoc->process( m_dataLength, m_DFWindowedFrame, m_magnitude, m_thetaAngle );
+
+    return runDF();
+}
+
+double DetectionFunction::process( double *magnitudes, double *phases )
+{
+    for (size_t i = 0; i < m_halfLength; ++i) {
+        m_magnitude[i] = magnitudes[i];
+        m_thetaAngle[i] = phases[i];
+    }
+
+    return runDF();
+}
+
+double DetectionFunction::runDF()
+{
     double retVal = 0;
-
-    m_window->cut( TDomain, m_DFWindowedFrame );
-	
-    m_phaseVoc->process( m_dataLength, m_DFWindowedFrame, m_magnitude, m_thetaAngle );
 
     switch( m_DFType )
     {
     case DF_HFC:
 	retVal = HFC( m_halfLength, m_magnitude);

     double temp = 0.0;
     double diff = 0.0;
 
     for( i = 0; i < length; i++)
     {
-	temp = fabs( (src[ i ] * src[ i ]) - (magHistory[ i ] * magHistory[ i ]) );
+	temp = fabs( (src[ i ] * src[ i ]) - (m_magHistory[ i ] * m_magHistory[ i ]) );
 		
 	diff= sqrt(temp);
 
 	if( src[ i ] > 0.1)
 	{
 	    val += diff;
 	}
 
-	magHistory[ i ] = src[ i ];
+	m_magHistory[ i ] = src[ i ];
     }
 
     return val;
 }
 

 
     double dev = 0;
 
     for( i = 0; i < length; i++)
     {
-	tmpPhase = (srcPhase[ i ]- 2*phaseHistory[ i ]+phaseHistoryOld[ i ]);
+	tmpPhase = (srcPhase[ i ]- 2*m_phaseHistory[ i ]+m_phaseHistoryOld[ i ]);
 	dev = MathUtilities::princarg( tmpPhase );
 		
 	if( srcMagnitude[ i  ] > 0.1)
 	{
 	    tmpVal  = fabs( dev);
 	    val += tmpVal ;
 	}
 
-	phaseHistoryOld[ i ] = phaseHistory[ i ] ;
-	phaseHistory[ i ] = srcPhase[ i ];
+	m_phaseHistoryOld[ i ] = m_phaseHistory[ i ] ;
+	m_phaseHistory[ i ] = srcPhase[ i ];
     }
 	
 	
     return val;
 }

     double tmpReal = 0;
     double tmpImag = 0;
    
     double dev = 0;
     ComplexData meas = ComplexData( 0, 0 );
-
-    for( i = 0; i < length; i++)
-    {
-	tmpPhase = (srcPhase[ i ]- 2*phaseHistory[ i ]+phaseHistoryOld[ i ]);
+    ComplexData j = ComplexData( 0, 1 );
+
+    for( i = 0; i < length; i++)
+    {
+	tmpPhase = (srcPhase[ i ]- 2*m_phaseHistory[ i ]+m_phaseHistoryOld[ i ]);
 	dev= MathUtilities::princarg( tmpPhase );
 		
-	meas = magHistory[i] - ( srcMagnitude[ i ] * exp( j * dev) );
+	meas = m_magHistory[i] - ( srcMagnitude[ i ] * exp( j * dev) );
 
 	tmpReal = real( meas );
 	tmpImag = imag( meas );
 
 	val += sqrt( (tmpReal * tmpReal) + (tmpImag * tmpImag) );
 		
-	phaseHistoryOld[ i ] = phaseHistory[ i ] ;
-	phaseHistory[ i ] = srcPhase[ i ];
-	magHistory[ i ] = srcMagnitude[ i ];
+	m_phaseHistoryOld[ i ] = m_phaseHistory[ i ] ;
+	m_phaseHistory[ i ] = srcPhase[ i ];
+	m_magHistory[ i ] = srcMagnitude[ i ];
     }
 
     return val;
 }