comparison CepstrumPitchTracker.cpp @ 13:9fa97de8692a track

Partial updates to new method (but this doesn't currently build)

 #include <complex>
 
 using std::string;
 using std::vector;
 
-CepstrumPitchTracker::Hypothesis::Hypothesis(Estimate s)
-{
-    m_state = Provisional;
-    m_pending.push_back(s);
+CepstrumPitchTracker::Hypothesis::Hypothesis()
+{
+    m_state = New;
     m_age = 0;
 }
 
 bool
 CepstrumPitchTracker::Hypothesis::isWithinTolerance(Estimate s)

 CepstrumPitchTracker::Hypothesis::isSatisfied()
 {
     return (m_pending.size() > 2);
 }
 
+void
+CepstrumPitchTracker::Hypothesis::advanceTime()
+{
+    ++m_age;
+}
+
 bool
 CepstrumPitchTracker::Hypothesis::test(Estimate s)
 {
-    if (m_state == Rejected || m_state == Expired) {
-        return false;
-    }
-
-    if (++m_age > 3) {
-        if (m_state == Satisfied) {
+    bool accept = false;
+
+    switch (m_state) {
+
+    case New:
+        m_state = Provisional;
+        accept = true;
+        break;
+
+    case Provisional:
+        if (m_age > 3) {
+            m_state = Rejected;
+        } else if (isWithinTolerance(s)) {
+            accept = true;
+        }
+        break;
+        
+    case Satisfied:
+        if (m_age > 3) {
             m_state = Expired;
-        } else {
-            m_state = Rejected;
-        }
-        return false;
-    }
-
-    if (isWithinTolerance(s)) {
+        } else if (isWithinTolerance(s)) {
+            accept = true;
+        }
+        break;
+
+    case Rejected:
+        break;
+
+    case Expired:
+        break;
+    }
+
+    if (accept) {
         m_pending.push_back(s);
-        if (m_state == Provisional) {
-            if (isSatisfied()) {
-                m_state == Satisfied;
-            }
-        }
         m_age = 0;
-        return true;
-    }
-    
-    return false;
-}
+        if (m_state == Provisional && isSatisfied()) {
+            m_state = Satisfied;
+        }
+    }
+
+    return accept;
+}        
 
 CepstrumPitchTracker::Hypothesis::State
 CepstrumPitchTracker::Hypothesis::getState()
 {
     return m_state;

     m_histlen(1),
     m_vflen(3),
     m_binFrom(0),
     m_binTo(0),
     m_bins(0),
-    m_accepted(0),
     m_history(0),
     m_prevpeak(0),
     m_prevprop(0)
 {
 }

             maxval = data[i];
             maxbin = i;
         }
     }
 
+    if (maxbin < 0) return fs;
+
+    double peakfreq = m_inputSampleRate / (maxbin + m_binFrom);
+    Hypothesis::Estimate e;
+    e.freq = peakfreq;
+    e.time = timestamp;
+
+    m_accepted.advanceTime();
+    for (int i = 0; i < m_possible.size(); ++i) {
+        m_possible[i].advanceTime();
+    }
+
+    if (m_accepted.test(e)) {
+        return fs;
+    }
+
+    //...
+
+/*
     bool accepted = false;
 
     if (maxbin >= 0) {
         double pp = calculatePeakProportion(data, abstot, maxbin);
         if (acceptPeak(maxbin, pp)) {

         if (accepted) {
             m_prevpeak = maxbin;
             m_prevprop = pp;
         }
     }
-            
+*/
 //    std::cerr << "peakProportion = " << peakProportion << std::endl;
 //    std::cerr << "peak = " << m_inputSampleRate / (maxbin + m_binFrom) << std::endl;
 //    std::cerr << "bins = " << m_bins << std::endl;
 
 //    if (peakProportion >= (0.00006 * m_bins)) {