comparison CepstrumPitchTracker.cpp @ 30:2554aab152a5

Another tidy

 CepstrumPitchTracker::Hypothesis::~Hypothesis()
 {
 }
 
 bool
-CepstrumPitchTracker::Hypothesis::isWithinTolerance(Estimate s)
+CepstrumPitchTracker::Hypothesis::isWithinTolerance(Estimate s) const
 {
     if (m_pending.empty()) {
         return true;
     }
 

     
     return true;
 }
 
 bool
-CepstrumPitchTracker::Hypothesis::isOutOfDateFor(Estimate s)
+CepstrumPitchTracker::Hypothesis::isOutOfDateFor(Estimate s) const
 {
     if (m_pending.empty()) return false;
 
     return ((s.time - m_pending[m_pending.size()-1].time) > 
             RealTime::fromMilliseconds(40));
 }
 
 bool 
-CepstrumPitchTracker::Hypothesis::isSatisfied()
+CepstrumPitchTracker::Hypothesis::isSatisfied() const
 {
     if (m_pending.empty()) return false;
     
     double meanConfidence = 0.0;
     for (int i = 0; i < m_pending.size(); ++i) {

 
     int lengthRequired = 10000;
     if (meanConfidence > 0.0) {
         lengthRequired = int(2.0 / meanConfidence + 0.5);
     }
-    std::cerr << "meanConfidence = " << meanConfidence << ", lengthRequired = " << lengthRequired << ", length = " << m_pending.size() << std::endl;
 
     return (m_pending.size() > lengthRequired);
 }
 
 bool

 
     return accept;
 }        
 
 CepstrumPitchTracker::Hypothesis::State
-CepstrumPitchTracker::Hypothesis::getState()
+CepstrumPitchTracker::Hypothesis::getState() const
 {
     return m_state;
 }
 
 CepstrumPitchTracker::Hypothesis::Estimates
-CepstrumPitchTracker::Hypothesis::getAcceptedEstimates()
+CepstrumPitchTracker::Hypothesis::getAcceptedEstimates() const
 {
     if (m_state == Satisfied || m_state == Expired) {
         return m_pending;
     } else {
         return Estimates();
     }
 }
 
 double
-CepstrumPitchTracker::Hypothesis::getMeanFrequency()
+CepstrumPitchTracker::Hypothesis::getMeanFrequency() const
 {
     double acc = 0.0;
     for (int i = 0; i < m_pending.size(); ++i) {
         acc += m_pending[i].freq;
     }
     acc /= m_pending.size();
     return acc;
 }
 
 CepstrumPitchTracker::Hypothesis::Note
-CepstrumPitchTracker::Hypothesis::getAveragedNote()
+CepstrumPitchTracker::Hypothesis::getAveragedNote() const
 {
     Note n;
 
     if (!(m_state == Satisfied || m_state == Expired)) {
         n.freq = 0.0;

         return n;
     }
 
     n.time = m_pending.begin()->time;
 
-    Estimates::iterator i = m_pending.end();
+    Estimates::const_iterator i = m_pending.end();
     --i;
     n.duration = i->time - n.time;
 
     // just mean frequency for now, but this isn't at all right perceptually
     n.freq = getMeanFrequency();
     
     return n;
-}
-
-void
-CepstrumPitchTracker::Hypothesis::addFeatures(FeatureSet &fs)
-{
-    for (int i = 0; i < m_pending.size(); ++i) {
-	Feature f;
-	f.hasTimestamp = true;
-	f.timestamp = m_pending[i].time;
-	f.values.push_back(m_pending[i].freq);
-	fs[0].push_back(f);
-    }
-
-    Feature nf;
-    nf.hasTimestamp = true;
-    nf.hasDuration = true;
-    Note n = getAveragedNote();
-    nf.timestamp = n.time;
-    nf.duration = n.duration;
-    nf.values.push_back(n.freq);
-    fs[1].push_back(nf);
 }
 
 CepstrumPitchTracker::CepstrumPitchTracker(float inputSampleRate) :
     Plugin(inputSampleRate),
     m_channels(0),

 CepstrumPitchTracker::reset()
 {
 }
 
 void
+CepstrumPitchTracker::addFeaturesFrom(Hypothesis h, FeatureSet &fs)
+{
+    Hypothesis::Estimates es = h.getAcceptedEstimates();
+
+    for (int i = 0; i < es.size(); ++i) {
+	Feature f;
+	f.hasTimestamp = true;
+	f.timestamp = es[i].time;
+	f.values.push_back(es[i].freq);
+	fs[0].push_back(f);
+    }
+
+    Feature nf;
+    nf.hasTimestamp = true;
+    nf.hasDuration = true;
+    Hypothesis::Note n = h.getAveragedNote();
+    nf.timestamp = n.time;
+    nf.duration = n.duration;
+    nf.values.push_back(n.freq);
+    fs[1].push_back(nf);
+}
+
+void
 CepstrumPitchTracker::filter(const double *cep, double *data)
 {
     for (int i = 0; i < m_bins; ++i) {
         double v = 0;
         int n = 0;

             h.accept(e); //!!! must succeed as h is new, so perhaps there should be a ctor for this
             m_possible.push_back(h);
         }
 
         if (m_good.getState() == Hypothesis::Expired) {
-            m_good.addFeatures(fs);
+            addFeaturesFrom(m_good, fs);
         }
         
         if (m_good.getState() == Hypothesis::Expired ||
             m_good.getState() == Hypothesis::Rejected) {
             if (candidate >= 0) {

 CepstrumPitchTracker::FeatureSet
 CepstrumPitchTracker::getRemainingFeatures()
 {
     FeatureSet fs;
     if (m_good.getState() == Hypothesis::Satisfied) {
-        m_good.addFeatures(fs);
+        addFeaturesFrom(m_good, fs);
     }
     return fs;
 }