comparison layer/SpectrumLayer.cpp @ 284:1284955856ab

* threshold, show-peaks properties in spectrum

     m_channel(-1),
     m_channelSet(false),
     m_windowSize(1024),
     m_windowType(HanningWindow),
     m_windowHopLevel(2),
+    m_showPeaks(false),
     m_newFFTNeeded(true)
 {
     Preferences *prefs = Preferences::getInstance();
     connect(prefs, SIGNAL(propertyChanged(PropertyContainer::PropertyName)),
             this, SLOT(preferenceChanged(PropertyContainer::PropertyName)));

         return;
     }
 
     m_channel = channel;
 
-//!!!    if (!fft) setupFFT();
-
     emit layerParametersChanged();
 }
 
 Layer::PropertyList
 SpectrumLayer::getProperties() const
 {
     PropertyList list = SliceLayer::getProperties();
     list.push_back("Window Size");
     list.push_back("Window Increment");
+    list.push_back("Show Peak Frequencies");
     return list;
 }
 
 QString
 SpectrumLayer::getPropertyLabel(const PropertyName &name) const
 {
     if (name == "Window Size") return tr("Window Size");
     if (name == "Window Increment") return tr("Window Overlap");
+    if (name == "Show Peak Frequencies") return tr("Show Peak Frequencies");
     return SliceLayer::getPropertyLabel(name);
 }
 
 Layer::PropertyType
 SpectrumLayer::getPropertyType(const PropertyName &name) const
 {
     if (name == "Window Size") return ValueProperty;
     if (name == "Window Increment") return ValueProperty;
+    if (name == "Show Peak Frequencies") return ToggleProperty;
     return SliceLayer::getPropertyType(name);
 }
 
 QString
 SpectrumLayer::getPropertyGroupName(const PropertyName &name) const
 {
     if (name == "Window Size" ||
 	name == "Window Increment") return tr("Window");
+    if (name == "Show Peak Frequencies") return tr("Plot Type");
     return SliceLayer::getPropertyGroupName(name);
 }
 
 int
 SpectrumLayer::getPropertyRangeAndValue(const PropertyName &name,

 	*max = 5;
         *deflt = 2;
 	
         val = m_windowHopLevel;
     
+    } else if (name == "Show Peak Frequencies") {
+
+        return m_showPeaks ? 1 : 0;
+
     } else {
 
         val = SliceLayer::getPropertyRangeAndValue(name, min, max, deflt);
     }
 

 {
     if (name == "Window Size") {
 	setWindowSize(32 << value);
     } else if (name == "Window Increment") {
         setWindowHopLevel(value);
+    } else if (name == "Show Peak Frequencies") {
+        setShowPeaks(value ? true : false);
     } else {
         SliceLayer::setProperty(name, value);
     }
 }
 
 void
 SpectrumLayer::setWindowSize(size_t ws)
 {
     if (m_windowSize == ws) return;
     m_windowSize = ws;
-//!!!    setupFFT();
     m_newFFTNeeded = true;
     emit layerParametersChanged();
 }
 
 void
 SpectrumLayer::setWindowHopLevel(size_t v)
 {
     if (m_windowHopLevel == v) return;
     m_windowHopLevel = v;
-//!!!    setupFFT();
     m_newFFTNeeded = true;
     emit layerParametersChanged();
 }
 
 void
 SpectrumLayer::setWindowType(WindowType w)
 {
     if (m_windowType == w) return;
     m_windowType = w;
-//!!!    setupFFT();
     m_newFFTNeeded = true;
+    emit layerParametersChanged();
+}
+
+void
+SpectrumLayer::setShowPeaks(bool show)
+{
+    if (m_showPeaks == show) return;
+    m_showPeaks = show;
     emit layerParametersChanged();
 }
 
 void
 SpectrumLayer::preferenceChanged(PropertyContainer::PropertyName name)

 {
     value = getValueForY(y, v);
 
     if (m_energyScale == dBScale || m_energyScale == MeterScale) {
 
-        float thresh = -80.f;
-
         if (value > 0.f) {
             value = 10.f * log10f(value);
-            if (value < thresh) value = thresh;
-        } else value = thresh;
+            if (value < m_threshold) value = m_threshold;
+        } else value = m_threshold;
 
         unit = "dBV";
 
     } else {
         unit = "V";

                            pitchLabel,
                            View::OutlinedText);
     }
 
     float value = getValueForY(cursorPos.y(), v);
-    float thresh = -80.f;
+    float thresh = m_threshold;
     float db = thresh;
     if (value > 0.f) db = 10.f * log10f(value);
     if (db < thresh) db = thresh;
 
     v->drawVisibleText(paint,

     int w = v->width() - xorigin - 1;
 
     int pkh = 0;
     if (m_binScale == LogBins) pkh = 10;
 
-    if (fft) {
+    if (fft && m_showPeaks) {
 
         // draw peak lines
-        //!!! should be optional
 
         size_t col = v->getCentreFrame() / fft->getResolution();
 
         paint.save();
         paint.setRenderHint(QPainter::Antialiasing, false);

 
 	    int n = (i % 12);
 
             if (n == 1) {
                 // C# -- fill the C from here
+                QColor col = Qt::gray;
+                if (i == 61) { // filling middle C
+                    col = Qt::blue;
+                    col = col.light(150);
+                }
                 if (x - ppx > 2) {
                     paint.fillRect((px + ppx) / 2 + 1,
                                    h - pkh,
                                    x - (px + ppx) / 2 - 1,
                                    pkh,
-                                   Qt::gray);
+                                   col);
                 }
             }
 
 	    if (n == 1 || n == 3 || n == 6 || n == 8 || n == 10) {
 		// black notes