comparison layer/SpectrogramLayer.cpp @ 1137:4e7ed3252d80 spectrogram-minor-refactor

Re-implement dB^2 (log-power) spectrogram setting

     m_initialRotation(0),
     m_minFrequency(10),
     m_maxFrequency(8000),
     m_initialMaxFrequency(8000),
     m_colourScale(ColourScaleType::Log),
+    m_colourScaleMultiple(1.0),
     m_colourMap(0),
     m_binScale(BinScale::Linear),
     m_binDisplay(BinDisplay::AllBins),
     m_normalization(ColumnNormalization::None),
     m_normalizeVisibleArea(false),

 {
     invalidateRenderers();
     invalidateFFTModel();
 }
 
-ColourScaleType
+pair<ColourScaleType, double>
 SpectrogramLayer::convertToColourScale(int value)
 {
     switch (value) {
-    case 0: return ColourScaleType::Linear;
-    case 1: return ColourScaleType::Meter;
-    case 2: return ColourScaleType::Log; //!!! db^2
-    case 3: return ColourScaleType::Log;
-    case 4: return ColourScaleType::Phase;
-    default: return ColourScaleType::Linear;
+    case 0: return { ColourScaleType::Linear, 1.0 };
+    case 1: return { ColourScaleType::Meter, 1.0 };
+    case 2: return { ColourScaleType::Log, 2.0 }; // dB^2 (i.e. log of power)
+    case 3: return { ColourScaleType::Log, 1.0 }; // dB   (of magnitude)
+    case 4: return { ColourScaleType::Phase, 1.0 };
+    default: return { ColourScaleType::Linear, 1.0 };
     }
 }
 
 int
-SpectrogramLayer::convertFromColourScale(ColourScaleType scale)
+SpectrogramLayer::convertFromColourScale(ColourScaleType scale, double multiple)
 {
     switch (scale) {
     case ColourScaleType::Linear: return 0;
     case ColourScaleType::Meter: return 1;
-    case ColourScaleType::Log: return 3; //!!! + db^2
+    case ColourScaleType::Log: return (multiple > 1.5 ? 2 : 3);
     case ColourScaleType::Phase: return 4;
-
     case ColourScaleType::PlusMinusOne:
     case ColourScaleType::Absolute:
     default: return 0;
     }
 }

         // linear, meter, db^2, db, phase
 	*min = 0;
 	*max = 4;
         *deflt = 2;
 
-	val = convertFromColourScale(m_colourScale);
+	val = convertFromColourScale(m_colourScale, m_colourScaleMultiple);
 
     } else if (name == "Colour") {
 
 	*min = 0;
 	*max = ColourMapper::getColourMapCount() - 1;

         if (vs != m_lastEmittedZoomStep) {
             emit verticalZoomChanged();
             m_lastEmittedZoomStep = vs;
         }
     } else if (name == "Colour Scale") {
+        setColourScaleMultiple(1.0);
 	switch (value) {
 	default:
 	case 0: setColourScale(ColourScaleType::Linear); break;
 	case 1: setColourScale(ColourScaleType::Meter); break;
-	case 2: setColourScale(ColourScaleType::Log); break; //!!! dB^2
+	case 2:
+            setColourScale(ColourScaleType::Log);
+            setColourScaleMultiple(2.0);
+            break;
 	case 3: setColourScale(ColourScaleType::Log); break;
 	case 4: setColourScale(ColourScaleType::Phase); break;
 	}
     } else if (name == "Frequency Scale") {
 	switch (value) {

 {
     return m_colourScale;
 }
 
 void
+SpectrogramLayer::setColourScaleMultiple(double multiple)
+{
+    if (m_colourScaleMultiple == multiple) return;
+
+    invalidateRenderers();
+    
+    m_colourScaleMultiple = multiple;
+    
+    emit layerParametersChanged();
+}
+
+double
+SpectrogramLayer::getColourScaleMultiple() const
+{
+    return m_colourScaleMultiple;
+}
+
+void
 SpectrogramLayer::setColourMap(int map)
 {
     if (m_colourMap == map) return;
 
     invalidateRenderers();

         sources.source = sources.fft;
         sources.peaks = getPeakCache();
 
         ColourScale::Parameters cparams;
         cparams.colourMap = m_colourMap;
-        cparams.scale = m_colourScale;
+        cparams.scaleType = m_colourScale;
+        cparams.multiple = m_colourScaleMultiple;
 
         if (m_colourScale != ColourScaleType::Phase) {
             cparams.gain = m_gain;
             cparams.threshold = m_threshold;
         }

         if (m_normalizeVisibleArea && m_viewMags[viewId].isSet()) {
             minValue = m_viewMags[viewId].getMin();
             maxValue = m_viewMags[viewId].getMax();
         } else if (m_colourScale == ColourScaleType::Linear &&
                    m_normalization == ColumnNormalization::None) {
-            //!!! This should not be necessary -- what is the actual range
             maxValue = 0.1f;
         }
 
         if (maxValue <= minValue) {
             maxValue = minValue + 0.1f;

 		 "colourRotation=\"%5\" "
 		 "frequencyScale=\"%6\" "
 		 "binDisplay=\"%7\" ")
 	.arg(m_minFrequency)
 	.arg(m_maxFrequency)
-	.arg(convertFromColourScale(m_colourScale))
+	.arg(convertFromColourScale(m_colourScale, m_colourScaleMultiple))
 	.arg(m_colourMap)
 	.arg(m_colourRotation)
 	.arg(int(m_binScale))
 	.arg(int(m_binDisplay));
 

     if (ok) {
         SVDEBUG << "SpectrogramLayer::setProperties: setting max freq to " << maxFrequency << endl;
         setMaxFrequency(maxFrequency);
     }
 
-    ColourScaleType colourScale = convertToColourScale
+    auto colourScale = convertToColourScale
         (attributes.value("colourScale").toInt(&ok));
-    if (ok) setColourScale(colourScale);
+    if (ok) {
+        setColourScale(colourScale.first);
+        setColourScaleMultiple(colourScale.second);
+    }
 
     int colourMap = attributes.value("colourScheme").toInt(&ok);
     if (ok) setColourMap(colourMap);
 
     int colourRotation = attributes.value("colourRotation").toInt(&ok);