comparison data/model/FFTModel.cpp @ 1206:659372323b45 tony-2.0-integration

Merge latest SV 3.0 branch code

 FFTModel::Column
 FFTModel::getColumn(int x) const
 {
     auto cplx = getFFTColumn(x);
     Column col;
-    col.reserve(int(cplx.size()));
+    col.reserve(cplx.size());
     for (auto c: cplx) col.push_back(abs(c));
-    return col;
+    return move(col);
+}
+
+FFTModel::Column
+FFTModel::getPhases(int x) const
+{
+    auto cplx = getFFTColumn(x);
+    Column col;
+    col.reserve(cplx.size());
+    for (auto c: cplx) {
+        col.push_back(arg(c));
+    }
+    return move(col);
 }
 
 float
 FFTModel::getMagnitudeAt(int x, int y) const
 {

 float
 FFTModel::getMaximumMagnitudeAt(int x) const
 {
     Column col(getColumn(x));
     float max = 0.f;
-    for (int i = 0; i < col.size(); ++i) {
+    int n = int(col.size());
+    for (int i = 0; i < n; ++i) {
         if (col[i] > max) max = col[i];
     }
     return max;
 }
 

 FFTModel::getValuesAt(int x, int y, float &re, float &im) const
 {
     auto col = getFFTColumn(x);
     re = col[y].real();
     im = col[y].imag();
-}
-
-bool
-FFTModel::isColumnAvailable(int) const
-{
-    //!!!
-    return true;
 }
 
 bool
 FFTModel::getMagnitudesAt(int x, float *values, int minbin, int count) const
 {

     auto col = getFFTColumn(x);
     for (int i = 0; i < count; ++i) {
         values[i] = abs(col[minbin + i]);
     }
     return true;
-}
-
-float
-FFTModel::getNormalizedMagnitudesAt(int x, float *values, int minbin, int count) const
-{
-    if (!getMagnitudesAt(x, values, minbin, count)) return false;
-    if (count == 0) count = getHeight();
-    float max = 0.f;
-    for (int i = 0; i < count; ++i) {
-        if (values[i] > max) max = values[i];
-    }
-    if (max > 0.f) {
-        for (int i = 0; i < count; ++i) {
-            values[i] /= max;
-        }
-    }
-    return max;
 }
 
 bool
 FFTModel::getPhasesAt(int x, float *values, int minbin, int count) const
 {

     if (m_cached.size() >= m_cacheSize) {
         m_cached.pop_front();
     }
     m_cached.push_back(sc);
 
-    return col;
+    return move(col);
 }
 
 bool
 FFTModel::estimateStableFrequency(int x, int y, double &frequency)
 {

 
     return true;
 }
 
 FFTModel::PeakLocationSet
-FFTModel::getPeaks(PeakPickType type, int x, int ymin, int ymax)
+FFTModel::getPeaks(PeakPickType type, int x, int ymin, int ymax) const
 {
     Profiler profiler("FFTModel::getPeaks");
 
     FFTModel::PeakLocationSet peaks;
     if (!isOK()) return peaks;

         }
         return peaks;
     }
 
     Column values = getColumn(x);
+    int nv = int(values.size());
 
     float mean = 0.f;
-    for (int i = 0; i < values.size(); ++i) mean += values[i];
-    if (values.size() > 0) mean = mean / float(values.size());
+    for (int i = 0; i < nv; ++i) mean += values[i];
+    if (nv > 0) mean = mean / float(values.size());
     
     // For peak picking we use a moving median window, picking the
     // highest value within each continuous region of values that
     // exceed the median.  For pitch adaptivity, we adjust the window
     // size to a roughly constant pitch range (about four tones).

     int binmin;
     if (ymin > halfWin) binmin = ymin - halfWin;
     else binmin = 0;
 
     int binmax;
-    if (ymax + halfWin < values.size()) binmax = ymax + halfWin;
-    else binmax = values.size()-1;
+    if (ymax + halfWin < nv) binmax = ymax + halfWin;
+    else binmax = nv - 1;
 
     int prevcentre = 0;
 
     for (int bin = binmin; bin <= binmax; ++bin) {
 

         }
 
         int actualSize = int(window.size());
 
         if (type == MajorPitchAdaptivePeaks) {
-            if (ymax + halfWin < values.size()) binmax = ymax + halfWin;
-            else binmax = values.size()-1;
+            if (ymax + halfWin < nv) binmax = ymax + halfWin;
+            else binmax = nv - 1;
         }
 
         deque<float> sorted(window);
         sort(sorted.begin(), sorted.end());
         float median = sorted[int(float(sorted.size()) * dist)];

 
             if (centre > median) {
                 inrange.push_back(centrebin);
             }
 
-            if (centre <= median || centrebin+1 == values.size()) {
+            if (centre <= median || centrebin+1 == nv) {
                 if (!inrange.empty()) {
                     int peakbin = 0;
                     float peakval = 0.f;
                     for (int i = 0; i < (int)inrange.size(); ++i) {
                         if (i == 0 || values[inrange[i]] > peakval) {

     return medianWinSize;
 }
 
 FFTModel::PeakSet
 FFTModel::getPeakFrequencies(PeakPickType type, int x,
-                             int ymin, int ymax)
+                             int ymin, int ymax) const
 {
     Profiler profiler("FFTModel::getPeakFrequencies");
 
     PeakSet peaks;
     if (!isOK()) return peaks;