# HG changeset patch # User Chris Cannam # Date 1470306371 -3600 # Node ID 4e7ed3252d805ae03d83e5db192b1608d74eb962 # Parent 9ff838a64461fdd399b7fc85919c973810b641b3 Re-implement dB^2 (log-power) spectrogram setting diff -r 9ff838a64461 -r 4e7ed3252d80 layer/Colour3DPlotLayer.cpp --- a/layer/Colour3DPlotLayer.cpp Wed Aug 03 16:16:23 2016 +0100 +++ b/layer/Colour3DPlotLayer.cpp Thu Aug 04 11:26:11 2016 +0100 @@ -1036,7 +1036,7 @@ ColourScale::Parameters cparams; cparams.colourMap = m_colourMap; - cparams.scale = m_colourScale; + cparams.scaleType = m_colourScale; cparams.gain = m_gain; if (m_normalization == ColumnNormalization::None) { diff -r 9ff838a64461 -r 4e7ed3252d80 layer/ColourScale.cpp --- a/layer/ColourScale.cpp Wed Aug 03 16:16:23 2016 +0100 +++ b/layer/ColourScale.cpp Thu Aug 04 11:26:11 2016 +0100 @@ -42,16 +42,16 @@ m_mappedMin = m_params.threshold; } - if (m_params.scale == ColourScaleType::Log) { + if (m_params.scaleType == ColourScaleType::Log) { LogRange::mapRange(m_mappedMin, m_mappedMax); - } else if (m_params.scale == ColourScaleType::PlusMinusOne) { + } else if (m_params.scaleType == ColourScaleType::PlusMinusOne) { m_mappedMin = -1.0; m_mappedMax = 1.0; - } else if (m_params.scale == ColourScaleType::Absolute) { + } else if (m_params.scaleType == ColourScaleType::Absolute) { m_mappedMin = fabs(m_mappedMin); m_mappedMax = fabs(m_mappedMax); @@ -64,7 +64,7 @@ cerr << "ERROR: ColourScale::ColourScale: minValue = " << m_params.minValue << ", maxValue = " << m_params.maxValue << ", threshold = " << m_params.threshold - << ", scale = " << int(m_params.scale) + << ", scale = " << int(m_params.scaleType) << " resulting in mapped minValue = " << m_mappedMin << ", mapped maxValue = " << m_mappedMax << endl; throw std::logic_error("maxValue must be greater than minValue [after mapping]"); @@ -78,7 +78,7 @@ ColourScaleType ColourScale::getScale() const { - return m_params.scale; + return m_params.scaleType; } int @@ -86,26 +86,30 @@ { double maxPixF = m_maxPixel; - if (m_params.scale == ColourScaleType::Phase) { + if (m_params.scaleType == ColourScaleType::Phase) { double half = (maxPixF - 1.f) / 2.f; return 1 + int((value * half) / M_PI + half); } value *= m_params.gain; +// value = pow(value, m_params.multiple); + if (value < m_params.threshold) return 0; double mapped = value; - if (m_params.scale == ColourScaleType::Log) { + if (m_params.scaleType == ColourScaleType::Log) { mapped = LogRange::map(value); - } else if (m_params.scale == ColourScaleType::PlusMinusOne) { + } else if (m_params.scaleType == ColourScaleType::PlusMinusOne) { if (mapped < -1.f) mapped = -1.f; if (mapped > 1.f) mapped = 1.f; - } else if (m_params.scale == ColourScaleType::Absolute) { + } else if (m_params.scaleType == ColourScaleType::Absolute) { if (mapped < 0.f) mapped = -mapped; } - + + mapped *= m_params.multiple; + if (mapped < m_mappedMin) { mapped = m_mappedMin; } @@ -117,7 +121,7 @@ int pixel = 0; - if (m_params.scale == ColourScaleType::Meter) { + if (m_params.scaleType == ColourScaleType::Meter) { pixel = AudioLevel::multiplier_to_preview(proportion, m_maxPixel-1) + 1; } else { pixel = int(proportion * maxPixF) + 1; diff -r 9ff838a64461 -r 4e7ed3252d80 layer/ColourScale.h --- a/layer/ColourScale.h Wed Aug 03 16:16:23 2016 +0100 +++ b/layer/ColourScale.h Thu Aug 04 11:26:11 2016 +0100 @@ -35,15 +35,15 @@ { public: struct Parameters { - Parameters() : colourMap(0), scale(ColourScaleType::Linear), + Parameters() : colourMap(0), scaleType(ColourScaleType::Linear), minValue(0.0), maxValue(1.0), - threshold(0.0), gain(1.0) { } + threshold(0.0), gain(1.0), multiple(1.0) { } /** A colour map index as used by ColourMapper */ int colourMap; /** Distribution for the scale */ - ColourScaleType scale; + ColourScaleType scaleType; /** Minimum value in source range */ double minValue; @@ -55,8 +55,15 @@ pixel 0 */ double threshold; - /** Gain to apply before clamping and mapping */ + /** Gain to apply before thresholding, mapping, and clamping */ double gain; + + /** Multiple to apply after thresholding and mapping. In most + * cases the gain parameter is the one you want instead of + * this, but this can be used for example with Log scale to + * produce the log of some power of the original value, + * e.g. multiple = 2 gives log(x^2). */ + double multiple; }; /** diff -r 9ff838a64461 -r 4e7ed3252d80 layer/SpectrogramLayer.cpp --- a/layer/SpectrogramLayer.cpp Wed Aug 03 16:16:23 2016 +0100 +++ b/layer/SpectrogramLayer.cpp Thu Aug 04 11:26:11 2016 +0100 @@ -73,6 +73,7 @@ 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), @@ -135,28 +136,27 @@ invalidateFFTModel(); } -ColourScaleType +pair 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; @@ -330,7 +330,7 @@ *max = 4; *deflt = 2; - val = convertFromColourScale(m_colourScale); + val = convertFromColourScale(m_colourScale, m_colourScaleMultiple); } else if (name == "Colour") { @@ -590,11 +590,15 @@ 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; } @@ -878,6 +882,24 @@ } 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; @@ -1408,7 +1430,8 @@ 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; @@ -1423,7 +1446,6 @@ 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; } @@ -2384,7 +2406,7 @@ "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)) @@ -2459,9 +2481,12 @@ 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); diff -r 9ff838a64461 -r 4e7ed3252d80 layer/SpectrogramLayer.h --- a/layer/SpectrogramLayer.h Wed Aug 03 16:16:23 2016 +0100 +++ b/layer/SpectrogramLayer.h Thu Aug 04 11:26:11 2016 +0100 @@ -145,6 +145,13 @@ ColourScaleType getColourScale() const; /** + * Specify multiple factor for colour scale. This is 2.0 for + * log-power spectrogram and 1.0 otherwise. + */ + void setColourScaleMultiple(double); + double getColourScaleMultiple() const; + + /** * Specify the scale for the y axis. */ void setBinScale(BinScale); @@ -249,6 +256,7 @@ int m_maxFrequency; int m_initialMaxFrequency; ColourScaleType m_colourScale; + double m_colourScaleMultiple; int m_colourMap; QColor m_crosshairColour; BinScale m_binScale; @@ -260,8 +268,8 @@ mutable bool m_haveDetailedScale; - static ColourScaleType convertToColourScale(int value); - static int convertFromColourScale(ColourScaleType); + static std::pair convertToColourScale(int value); + static int convertFromColourScale(ColourScaleType type, double multiple); static std::pair convertToColumnNorm(int value); static int convertFromColumnNorm(ColumnNormalization norm, bool visible);