comparison layer/SpectrogramLayer.cpp @ 1395:32bbb86094c3

Merge from branch spectrogramparam

     m_model(0),
     m_channel(0),
     m_windowSize(1024),
     m_windowType(HanningWindow),
     m_windowHopLevel(2),
+    m_oversampling(1),
     m_gain(1.0),
     m_initialGain(1.0),
     m_threshold(1.0e-8f),
     m_initialThreshold(1.0e-8f),
     m_colourRotation(0),

     PropertyList list;
     list.push_back("Colour");
     list.push_back("Colour Scale");
     list.push_back("Window Size");
     list.push_back("Window Increment");
+    list.push_back("Oversampling");
     list.push_back("Normalization");
     list.push_back("Bin Display");
     list.push_back("Threshold");
     list.push_back("Gain");
     list.push_back("Colour Rotation");

 {
     if (name == "Colour") return tr("Colour");
     if (name == "Colour Scale") return tr("Colour Scale");
     if (name == "Window Size") return tr("Window Size");
     if (name == "Window Increment") return tr("Window Overlap");
+    if (name == "Oversampling") return tr("Oversampling");
     if (name == "Normalization") return tr("Normalization");
     if (name == "Bin Display") return tr("Bin Display");
     if (name == "Threshold") return tr("Threshold");
     if (name == "Gain") return tr("Gain");
     if (name == "Colour Rotation") return tr("Colour Rotation");

 SpectrogramLayer::getPropertyGroupName(const PropertyName &name) const
 {
     if (name == "Bin Display" ||
         name == "Frequency Scale") return tr("Bins");
     if (name == "Window Size" ||
-        name == "Window Increment") return tr("Window");
+        name == "Window Increment" ||
+        name == "Oversampling") return tr("Window");
     if (name == "Colour" ||
         name == "Threshold" ||
         name == "Colour Rotation") return tr("Colour");
     if (name == "Normalization" ||
         name == "Gain" ||

         *min = 0;
         *max = 5;
         *deflt = 2;
 
         val = m_windowHopLevel;
-    
+
+    } else if (name == "Oversampling") {
+
+        *min = 0;
+        *max = 3;
+        *deflt = 0;
+
+        val = 0;
+        int ov = m_oversampling;
+        while (ov > 1) { ov >>= 1; val ++; }
+        
     } else if (name == "Min Frequency") {
 
         *min = 0;
         *max = 9;
         *deflt = 1;

         case 1: return tr("25 %");
         case 2: return tr("50 %");
         case 3: return tr("75 %");
         case 4: return tr("87.5 %");
         case 5: return tr("93.75 %");
+        }
+    }
+    if (name == "Oversampling") {
+        switch (value) {
+        default:
+        case 0: return tr("1x");
+        case 1: return tr("2x");
+        case 2: return tr("4x");
+        case 3: return tr("8x");
         }
     }
     if (name == "Min Frequency") {
         switch (value) {
         default:

         setColourMap(value);
     } else if (name == "Window Size") {
         setWindowSize(32 << value);
     } else if (name == "Window Increment") {
         setWindowHopLevel(value);
+    } else if (name == "Oversampling") {
+        setOversampling(1 << value);
     } else if (name == "Min Frequency") {
         switch (value) {
         default:
         case 0: setMinFrequency(0); break;
         case 1: setMinFrequency(10); break;

 {
     return m_channel;
 }
 
 int
-SpectrogramLayer::getFFTOversampling() const
-{
+SpectrogramLayer::getFFTSize() const
+{
+    return m_windowSize * m_oversampling;
+}
+
+void
+SpectrogramLayer::setWindowSize(int ws)
+{
+    if (m_windowSize == ws) return;
+    invalidateRenderers();
+    m_windowSize = ws;
+    recreateFFTModel();
+    emit layerParametersChanged();
+}
+
+int
+SpectrogramLayer::getWindowSize() const
+{
+    return m_windowSize;
+}
+
+void
+SpectrogramLayer::setWindowHopLevel(int v)
+{
+    if (m_windowHopLevel == v) return;
+    invalidateRenderers();
+    m_windowHopLevel = v;
+    recreateFFTModel();
+    emit layerParametersChanged();
+}
+
+int
+SpectrogramLayer::getWindowHopLevel() const
+{
+    return m_windowHopLevel;
+}
+
+void
+SpectrogramLayer::setOversampling(int oversampling)
+{
+    if (m_oversampling == oversampling) return;
+    invalidateRenderers();
+    m_oversampling = oversampling;
+    recreateFFTModel();
+    emit layerParametersChanged();
+}
+
+int
+SpectrogramLayer::getOversampling() const
+{
+    return m_oversampling;
+    /*!!!
     if (m_binDisplay != BinDisplay::AllBins) {
         return 1;
     }
 
     Preferences::SpectrogramSmoothing smoothing = 

         smoothing == Preferences::SpectrogramInterpolated) {
         return 1;
     }
 
     return 4;
-}
-
-int
-SpectrogramLayer::getFFTSize() const
-{
-    return m_windowSize * getFFTOversampling();
-}
-
-void
-SpectrogramLayer::setWindowSize(int ws)
-{
-    if (m_windowSize == ws) return;
-
-    invalidateRenderers();
-    
-    m_windowSize = ws;
-    
-    recreateFFTModel();
-
-    emit layerParametersChanged();
-}
-
-int
-SpectrogramLayer::getWindowSize() const
-{
-    return m_windowSize;
-}
-
-void
-SpectrogramLayer::setWindowHopLevel(int v)
-{
-    if (m_windowHopLevel == v) return;
-
-    invalidateRenderers();
-    
-    m_windowHopLevel = v;
-    
-    recreateFFTModel();
-
-    emit layerParametersChanged();
-}
-
-int
-SpectrogramLayer::getWindowHopLevel() const
-{
-    return m_windowHopLevel;
+    */
 }
 
 void
 SpectrogramLayer::setWindowType(WindowType w)
 {

     QString s;
     
     s += QString("channel=\"%1\" "
                  "windowSize=\"%2\" "
                  "windowHopLevel=\"%3\" "
-                 "gain=\"%4\" "
-                 "threshold=\"%5\" ")
+                 "oversampling=\"%4\" "
+                 "gain=\"%5\" "
+                 "threshold=\"%6\" ")
         .arg(m_channel)
         .arg(m_windowSize)
         .arg(m_windowHopLevel)
+        .arg(m_oversampling)
         .arg(m_gain)
         .arg(m_threshold);
 
     s += QString("minFrequency=\"%1\" "
                  "maxFrequency=\"%2\" "

             else if (windowOverlap == 75) setWindowHopLevel(3);
             else if (windowOverlap == 90) setWindowHopLevel(4);
         }
     }
 
+    int oversampling = attributes.value("oversampling").toUInt(&ok);
+    if (ok) setOversampling(oversampling);
+
     float gain = attributes.value("gain").toFloat(&ok);
     if (ok) setGain(gain);
 
     float threshold = attributes.value("threshold").toFloat(&ok);
     if (ok) setThreshold(threshold);