comparison layer/SpectrogramLayer.cpp @ 1063:a0f234acd6e7 spectrogram-minor-refactor

Pull out column ops into ColumnOp

 #include "base/Window.h"
 #include "base/Pitch.h"
 #include "base/Preferences.h"
 #include "base/RangeMapper.h"
 #include "base/LogRange.h"
+#include "base/ColumnOp.h"
 #include "widgets/CommandHistory.h"
 #include "ColourMapper.h"
 #include "ImageRegionFinder.h"
 #include "data/model/Dense3DModelPeakCache.h"
 #include "PianoScale.h"

     m_initialMaxFrequency(8000),
     m_colourScale(dBColourScale),
     m_colourMap(0),
     m_frequencyScale(LinearFrequencyScale),
     m_binDisplay(AllBins),
-    m_normalization(NoNormalization),
+    m_normalization(ColumnOp::NoNormalization),
     m_lastEmittedZoomStep(-1),
     m_synchronous(false),
     m_haveDetailedScale(false),
     m_exiting(false),
     m_peakCacheDivisor(8),

 	setMaxFrequency(2000);
 	setMinFrequency(40);
 	setFrequencyScale(LogFrequencyScale);
 	setColourScale(LinearColourScale);
 	setBinDisplay(PeakFrequencies);
-        setNormalization(NormalizeColumns);
+        setNormalization(ColumnOp::NormalizeColumns);
         colourConfigName = "spectrogram-melodic-colour";
         colourConfigDefault = int(ColourMapper::Sunset);
     }
 
     QSettings settings;

 
     } else if (name == "Normalization") {
 	
         *min = 0;
         *max = 3;
-        *deflt = int(NoNormalization);
+        *deflt = int(ColumnOp::NoNormalization);
         val = (int)m_normalization;
 
     } else {
 	val = Layer::getPropertyRangeAndValue(name, min, max, deflt);
     }

 	case 2: setBinDisplay(PeakFrequencies); break;
 	}
     } else if (name == "Normalization") {
         switch (value) {
         default:
-        case 0: setNormalization(NoNormalization); break;
-        case 1: setNormalization(NormalizeColumns); break;
-        case 2: setNormalization(NormalizeVisibleArea); break;
-        case 3: setNormalization(NormalizeHybrid); break;
+        case 0: setNormalization(ColumnOp::NoNormalization); break;
+        case 1: setNormalization(ColumnOp::NormalizeColumns); break;
+        case 2: setNormalization(ColumnOp::NormalizeVisibleArea); break;
+        case 3: setNormalization(ColumnOp::NormalizeHybrid); break;
         }
     }
 }
 
 void

 {
     return m_binDisplay;
 }
 
 void
-SpectrogramLayer::setNormalization(Normalization n)
+SpectrogramLayer::setNormalization(ColumnOp::Normalization n)
 {
     if (m_normalization == n) return;
 
     invalidateImageCaches();
     invalidateMagnitudes();
     m_normalization = n;
 
     emit layerParametersChanged();
 }
 
-SpectrogramLayer::Normalization
+ColumnOp::Normalization
 SpectrogramLayer::getNormalization() const
 {
     return m_normalization;
 }
 

     int value;
 
     double min = 0.0;
     double max = 1.0;
 
-    if (m_normalization == NormalizeVisibleArea) {
+    if (m_normalization == ColumnOp::NormalizeVisibleArea) {
         min = m_viewMags[v->getId()].getMin();
         max = m_viewMags[v->getId()].getMax();
-    } else if (m_normalization != NormalizeColumns) {
+    } else if (m_normalization != ColumnOp::NormalizeColumns) {
         if (m_colourScale == LinearColourScale //||
 //            m_colourScale == MeterColourScale) {
             ) {
             max = 0.1;
         }

 
     if (updateViewMagnitudes(v)) {
 #ifdef DEBUG_SPECTROGRAM_REPAINT
         cerr << "SpectrogramLayer: magnitude range changed to [" << m_viewMags[v->getId()].getMin() << "->" << m_viewMags[v->getId()].getMax() << "]" << endl;
 #endif
-        if (m_normalization == NormalizeVisibleArea) {
+        if (m_normalization == ColumnOp::NormalizeVisibleArea) {
             cache.invalidate();
         }
     }
 
     if (cache.getZoomLevel() != zoomLevel ||

     paint.drawImage(pr.x(), pr.y(), cache.getImage(),
                     pr.x(), pr.y(), pr.width(), pr.height());
 
     if (!m_synchronous) {
 
-        if ((m_normalization != NormalizeVisibleArea) || !overallMagChanged) {
+        if ((m_normalization != ColumnOp::NormalizeVisibleArea) || !overallMagChanged) {
 
             QRect areaLeft(0, 0, cache.getValidLeft(), h);
             QRect areaRight(cache.getValidRight(), 0,
                             cache.getSize().width() - cache.getValidRight(), h);
 

                 peakfreqs = fft->getPeakFrequencies(FFTModel::AllPeaks, sx,
                                                     minbin, maxbin - 1);
                 if (m_colourScale == PhaseColourScale) {
                     fft->getPhasesAt(sx, values, minbin, maxbin - minbin + 1);
                     /*!!!
-                } else if (m_normalization == NormalizeColumns) {
+                } else if (m_normalization == ColumnOp::NormalizeColumns) {
                     fft->getNormalizedMagnitudesAt(sx, values, minbin, maxbin - minbin + 1);
-                } else if (m_normalization == NormalizeHybrid) {
+                } else if (m_normalization == ColumnOp::NormalizeHybrid) {
                     float max = fft->getNormalizedMagnitudesAt
                         (sx, values, minbin, maxbin - minbin + 1);
                     float scale = log10f(max + 1.f);
                     for (int i = minbin; i <= maxbin; ++i) {
                         values[i - minbin] *= scale;

                 if (bin > maxbin) break;
 
                 double value = values[bin - minbin];
 
                 if (m_colourScale != PhaseColourScale) {
-                    if (m_normalization != NormalizeColumns) {
+                    if (m_normalization != ColumnOp::NormalizeColumns) {
                         value /= (m_fftSize/2.0);
                     }
                     mag.sample(float(value));
                     value *= m_gain;
                 }

         
     return vector<float>(col.data() + minbin,
                          col.data() + minbin + bincount);
 }
 
-vector<float> 
-SpectrogramLayer::scaleColumn(const vector<float> &in) const
-{
-    if (m_normalization == NormalizeColumns ||
-        m_normalization == NormalizeHybrid) {
-        return in;
-    }
-    vector<float> out;
-    out.reserve(in.size());
-    float scale = 2.f / float(m_fftSize);
-    for (auto v: in) {
-        out.push_back(v * scale);
-    }
-    return out;
-}
-
-static bool
-is_peak(const vector<float> &values, int ix)
-{
-    if (!in_range_for(values, ix-1)) return false;
-    if (!in_range_for(values, ix+1)) return false;
-    if (values[ix] < values[ix+1]) return false;
-    if (values[ix] < values[ix-1]) return false;
-    return true;
-}
-
-vector<float>
-SpectrogramLayer::distributeColumn(const vector<float> &in,
-                                   int h,
-                                   const vector<double> &binfory,
-                                   int minbin,
-                                   bool interpolate) const
-{
-    vector<float> out(h, 0.f);
-    int bins = int(in.size());
-
-    for (int y = 0; y < h; ++y) {
-        
-        double sy0 = binfory[y] - minbin;
-        double sy1 = sy0 + 1;
-        if (y+1 < h) {
-            sy1 = binfory[y+1] - minbin;
-        }
-        
-        if (interpolate && fabs(sy1 - sy0) < 1.0) {
-            
-            double centre = (sy0 + sy1) / 2;
-            double dist = (centre - 0.5) - rint(centre - 0.5);
-            int bin = int(centre);
-
-            int other = (dist < 0 ? (bin-1) : (bin+1));
-
-            if (bin < 0) bin = 0;
-            if (bin >= bins) bin = bins-1;
-
-            if (other < 0 || other >= bins) {
-                other = bin;
-            }
-
-            double prop = 1.0 - fabs(dist);
-
-            double v0 = in[bin];
-            double v1 = in[other];
-                
-            out[y] = float(prop * v0 + (1.0 - prop) * v1);
-
-        } else { // not interpolating this one
-
-            int by0 = int(sy0 + 0.0001);
-            int by1 = int(sy1 + 0.0001);
-            if (by1 < by0 + 1) by1 = by0 + 1;
-
-            for (int bin = by0; bin < by1; ++bin) {
-
-                float value = in[bin];
-
-                if (value > out[y] || m_colourScale == PhaseColourScale) {
-                    out[y] = value;
-                }
-            }
-        }
-    }
-
-    return out;
-}
-
 void
 SpectrogramLayer::recordColumnExtents(const vector<float> &col,
                                       int sx, // column index, for m_columnMags
                                       MagnitudeRange &overallMag,
                                       bool &overallMagChanged) const
 {
     if (!in_range_for(m_columnMags, sx)) {
-        throw logic_error("sx out of range for m_columnMags");
+        m_columnMags.resize(sx + 1);
     }
     MagnitudeRange mr;
     for (auto v: col) {
         mr.sample(v);
     }
     m_columnMags[sx] = mr;
     if (overallMag.sample(mr)) {
         overallMagChanged = true;
     }
 }
-
-vector<float>
-SpectrogramLayer::normalizeColumn(const vector<float> &in) const
-{
-    if (m_normalization == NoNormalization ||
-        m_normalization == NormalizeVisibleArea) {
-        // NormalizeVisibleArea is handled through adjustment to m_gain
-        return in;
-    }
-
-    float max = *max_element(in.begin(), in.end());
-
-    if (m_normalization == NormalizeColumns && max == 0.f) {
-        return in;
-    }
-
-    if (m_normalization == NormalizeHybrid && max <= 0.f) {
-        return in;
-    }
-    
-    vector<float> out;
-    out.reserve(in.size());
-
-    float scale;
-    if (m_normalization == NormalizeHybrid) {
-        scale = log10f(max + 1.f) / max;
-    } else {
-        scale = 1.f / max;
-    }
-    
-    for (auto v: in) {
-        out.push_back(v * scale);
-    }
-    return out;
-}
-
-vector<float>
-SpectrogramLayer::peakPickColumn(const vector<float> &in) const
-{
-    if (m_binDisplay == AllBins) return in;
-
-    vector<float> out(in.size(), 0.f);
-    
-    for (int i = 0; in_range_for(in, i); ++i) {
-        if (is_peak(in, i)) {
-            out[i] = in[i];
-        }
-    }
-
-    return out;
-}
-
-vector<float>
-SpectrogramLayer::applyDisplayGain(const vector<float> &in) const
-{
-    if (m_gain == 1.0) return in;
-
-    vector<float> out;
-    out.reserve(in.size());
-    for (auto v: in) {
-        out.push_back(v * m_gain);
-    }
-    return out;
-}
-
-// order:
-// get column -> scale -> record extents -> normalise -> peak pick -> apply display gain -> distribute/interpolate
 
 int
 SpectrogramLayer::paintDrawBuffer(LayerGeometryProvider *v,
                                   int w,
                                   int h,

 
             MagnitudeRange mag;
 
             if (sx != psx) {
 
-                vector<float> column;
+                // order: get column -> scale -> record extents ->
+                // normalise -> peak pick -> apply display gain ->
+                // distribute/interpolate
+
+                ColumnOp::Column column;
+
                 if (peakCacheModel) {
                     column = getColumnFromGenericModel(peakCacheModel,
                                                        sx,
                                                        minbin,
                                                        maxbin - minbin + 1);

                                                    sx,
                                                    minbin,
                                                    maxbin - minbin + 1);
                 }
 
-                column = scaleColumn(column);
-                
+                column = ColumnOp::fftScale(column, m_fftSize);
+
                 recordColumnExtents(column,
                                     sx,
                                     overallMag,
                                     overallMagChanged);
 
+                column = ColumnOp::normalize(column, m_normalization);
+
+                if (m_binDisplay == PeakBins) {
+                    column = ColumnOp::peakPick(column);
+                }
+
                 preparedColumn =
-                    distributeColumn(applyDisplayGain
-                                     (peakPickColumn
-                                      (normalizeColumn
-                                       (column))),
-                                     h,
-                                     binfory,
-                                     minbin,
-                                     interpolate);
+                    ColumnOp::distribute
+                    (ColumnOp::applyGain(column, m_gain),
+                     h,
+                     binfory,
+                     minbin,
+                     interpolate);
                 
                 psx = sx;
             }
 
             //!!! now peak of all preparedColumns for this pixel

     // normalization in future: write out the column normalization
     // type separately, and then whether we are normalizing visible
     // area as well afterwards
     
     s += QString("columnNormalization=\"%1\" ")
-        .arg(m_normalization == NormalizeColumns ? "peak" :
-             m_normalization == NormalizeHybrid ? "hybrid" : "none");
+        .arg(m_normalization == ColumnOp::NormalizeColumns ? "peak" :
+             m_normalization == ColumnOp::NormalizeHybrid ? "hybrid" : "none");
 
     // Old-style normalization attribute. We *don't* write out
     // normalizeHybrid here because the only release that would accept
     // it (Tony v1.0) has a totally different scale factor for
     // it. We'll just have to accept that session files from Tony
     // v2.0+ will look odd in Tony v1.0
     
     s += QString("normalizeColumns=\"%1\" ")
-	.arg(m_normalization == NormalizeColumns ? "true" : "false");
+	.arg(m_normalization == ColumnOp::NormalizeColumns ? "true" : "false");
 
     // And this applies to both old- and new-style attributes
     
     s += QString("normalizeVisibleArea=\"%1\" ")
-        .arg(m_normalization == NormalizeVisibleArea ? "true" : "false");
+        .arg(m_normalization == ColumnOp::NormalizeVisibleArea ? "true" : "false");
     
     Layer::toXml(stream, indent, extraAttributes + " " + s);
 }
 
 void

     if (columnNormalization != "") {
 
         haveNewStyleNormalization = true;
 
         if (columnNormalization == "peak") {
-            setNormalization(NormalizeColumns);
+            setNormalization(ColumnOp::NormalizeColumns);
         } else if (columnNormalization == "hybrid") {
-            setNormalization(NormalizeHybrid);
+            setNormalization(ColumnOp::NormalizeHybrid);
         } else if (columnNormalization == "none") {
             // do nothing
         } else {
             cerr << "NOTE: Unknown or unsupported columnNormalization attribute \""
                  << columnNormalization << "\"" << endl;

     if (!haveNewStyleNormalization) {
 
         bool normalizeColumns =
             (attributes.value("normalizeColumns").trimmed() == "true");
         if (normalizeColumns) {
-            setNormalization(NormalizeColumns);
+            setNormalization(ColumnOp::NormalizeColumns);
         }
 
         bool normalizeHybrid =
             (attributes.value("normalizeHybrid").trimmed() == "true");
         if (normalizeHybrid) {
-            setNormalization(NormalizeHybrid);
+            setNormalization(ColumnOp::NormalizeHybrid);
         }
     }
 
     bool normalizeVisibleArea =
 	(attributes.value("normalizeVisibleArea").trimmed() == "true");
     if (normalizeVisibleArea) {
-        setNormalization(NormalizeVisibleArea);
-    }
-
-    if (!haveNewStyleNormalization && m_normalization == NormalizeHybrid) {
+        setNormalization(ColumnOp::NormalizeVisibleArea);
+    }
+
+    if (!haveNewStyleNormalization && m_normalization == ColumnOp::NormalizeHybrid) {
         // Tony v1.0 is (and hopefully will remain!) the only released
         // SV-a-like to use old-style attributes when saving sessions
         // that ask for hybrid normalization. It saves them with the
         // wrong gain factor, so hack in a fix for that here -- this
         // gives us backward but not forward compatibility.