Mercurial > hg > svgui
diff layer/Colour3DPlotLayer.cpp @ 1148:c0d841cb8ab9 tony-2.0-integration
Merge latest SV 3.0 branch code
| author | Chris Cannam |
|---|---|
| date | Fri, 19 Aug 2016 15:58:57 +0100 |
| parents | 4e7ed3252d80 |
| children | 0edfed2c8482 |
line wrap: on
line diff
--- a/layer/Colour3DPlotLayer.cpp Tue Oct 20 12:55:09 2015 +0100 +++ b/layer/Colour3DPlotLayer.cpp Fri Aug 19 15:58:57 2016 +0100 @@ -15,16 +15,23 @@ #include "Colour3DPlotLayer.h" -#include "view/View.h" #include "base/Profiler.h" #include "base/LogRange.h" #include "base/RangeMapper.h" + #include "ColourMapper.h" +#include "LayerGeometryProvider.h" +#include "PaintAssistant.h" + +#include "data/model/Dense3DModelPeakCache.h" + +#include "view/ViewManager.h" #include <QPainter> #include <QImage> #include <QRect> #include <QTextStream> +#include <QSettings> #include <iostream> @@ -41,33 +48,92 @@ Colour3DPlotLayer::Colour3DPlotLayer() : m_model(0), - m_cache(0), - m_peaksCache(0), - m_cacheValidStart(0), - m_cacheValidEnd(0), - m_colourScale(LinearScale), + m_colourScale(ColourScaleType::Linear), m_colourScaleSet(false), m_colourMap(0), m_gain(1.0), - m_binScale(LinearBinScale), - m_normalizeColumns(false), + m_binScale(BinScale::Linear), + m_normalization(ColumnNormalization::None), m_normalizeVisibleArea(false), - m_normalizeHybrid(false), m_invertVertical(false), - m_rectified(false), m_opaque(false), m_smooth(false), m_peakResolution(256), m_miny(0), - m_maxy(0) + m_maxy(0), + m_synchronous(false), + m_peakCache(0), + m_peakCacheDivisor(8) { - + QSettings settings; + settings.beginGroup("Preferences"); + setColourMap(settings.value("colour-3d-plot-colour", ColourMapper::Green).toInt()); + settings.endGroup(); } Colour3DPlotLayer::~Colour3DPlotLayer() { - delete m_cache; - delete m_peaksCache; + invalidateRenderers(); + delete m_peakCache; +} + +ColourScaleType +Colour3DPlotLayer::convertToColourScale(int value) +{ + switch (value) { + default: + case 0: return ColourScaleType::Linear; + case 1: return ColourScaleType::Log; + case 2: return ColourScaleType::PlusMinusOne; + case 3: return ColourScaleType::Absolute; + } +} + +int +Colour3DPlotLayer::convertFromColourScale(ColourScaleType scale) +{ + switch (scale) { + case ColourScaleType::Linear: return 0; + case ColourScaleType::Log: return 1; + case ColourScaleType::PlusMinusOne: return 2; + case ColourScaleType::Absolute: return 3; + + case ColourScaleType::Meter: + case ColourScaleType::Phase: + default: return 0; + } +} + +std::pair<ColumnNormalization, bool> +Colour3DPlotLayer::convertToColumnNorm(int value) +{ + switch (value) { + default: + case 0: return { ColumnNormalization::None, false }; + case 1: return { ColumnNormalization::Max1, false }; + case 2: return { ColumnNormalization::None, true }; // visible area + case 3: return { ColumnNormalization::Hybrid, false }; + } +} + +int +Colour3DPlotLayer::convertFromColumnNorm(ColumnNormalization norm, bool visible) +{ + if (visible) return 2; + switch (norm) { + case ColumnNormalization::None: return 0; + case ColumnNormalization::Max1: return 1; + case ColumnNormalization::Hybrid: return 3; + + case ColumnNormalization::Sum1: + default: return 0; + } +} + +void +Colour3DPlotLayer::setSynchronousPainting(bool synchronous) +{ + m_synchronous = synchronous; } void @@ -92,7 +158,11 @@ } else if (model->getResolution() > 2) { m_peakResolution = 128; } - cacheInvalid(); + + delete m_peakCache; + m_peakCache = 0; + + invalidateRenderers(); emit modelReplaced(); emit sliceableModelReplaced(oldModel, model); @@ -101,34 +171,46 @@ void Colour3DPlotLayer::cacheInvalid() { - delete m_cache; - delete m_peaksCache; - m_cache = 0; - m_peaksCache = 0; - m_cacheValidStart = 0; - m_cacheValidEnd = 0; + invalidateRenderers(); } void -Colour3DPlotLayer::cacheInvalid(sv_frame_t startFrame, sv_frame_t endFrame) +Colour3DPlotLayer::cacheInvalid(sv_frame_t /* startFrame */, + sv_frame_t /* endFrame */) { - if (!m_cache || !m_model) return; + //!!! should do this only if the range is visible + delete m_peakCache; + m_peakCache = 0; + + invalidateRenderers(); +} - int modelResolution = m_model->getResolution(); - int start = int(startFrame / modelResolution); - int end = int(endFrame / modelResolution + 1); - if (m_cacheValidStart < end) m_cacheValidStart = end; - if (m_cacheValidEnd > start) m_cacheValidEnd = start; - if (m_cacheValidStart > m_cacheValidEnd) m_cacheValidEnd = m_cacheValidStart; +void +Colour3DPlotLayer::invalidateRenderers() +{ + for (ViewRendererMap::iterator i = m_renderers.begin(); + i != m_renderers.end(); ++i) { + delete i->second; + } + m_renderers.clear(); +} + +Dense3DModelPeakCache * +Colour3DPlotLayer::getPeakCache() const +{ + if (!m_peakCache) { + m_peakCache = new Dense3DModelPeakCache(m_model, m_peakCacheDivisor); + } + return m_peakCache; } void Colour3DPlotLayer::modelChanged() { - if (!m_colourScaleSet && m_colourScale == LinearScale) { + if (!m_colourScaleSet && m_colourScale == ColourScaleType::Linear) { if (m_model) { if (m_model->shouldUseLogValueScale()) { - setColourScale(LogScale); + setColourScale(ColourScaleType::Log); } else { m_colourScaleSet = true; } @@ -140,10 +222,10 @@ void Colour3DPlotLayer::modelChangedWithin(sv_frame_t startFrame, sv_frame_t endFrame) { - if (!m_colourScaleSet && m_colourScale == LinearScale) { + if (!m_colourScaleSet && m_colourScale == ColourScaleType::Linear) { if (m_model && m_model->getWidth() > 50) { if (m_model->shouldUseLogValueScale()) { - setColourScale(LogScale); + setColourScale(ColourScaleType::Log); } else { m_colourScaleSet = true; } @@ -158,12 +240,10 @@ PropertyList list; list.push_back("Colour"); list.push_back("Colour Scale"); - list.push_back("Normalize Columns"); - list.push_back("Normalize Visible Area"); + list.push_back("Normalization"); list.push_back("Gain"); list.push_back("Bin Scale"); list.push_back("Invert Vertical Scale"); - list.push_back("Show Rectified"); list.push_back("Opaque"); list.push_back("Smooth"); return list; @@ -174,10 +254,8 @@ { if (name == "Colour") return tr("Colour"); if (name == "Colour Scale") return tr("Scale"); - if (name == "Normalize Columns") return tr("Normalize Columns"); - if (name == "Normalize Visible Area") return tr("Normalize Visible Area"); + if (name == "Normalization") return tr("Normalization"); if (name == "Invert Vertical Scale") return tr("Invert Vertical Scale"); - if (name == "Show Rectified") return tr("Half-Wave Rectify"); if (name == "Gain") return tr("Gain"); if (name == "Opaque") return tr("Always Opaque"); if (name == "Smooth") return tr("Smooth"); @@ -188,10 +266,7 @@ QString Colour3DPlotLayer::getPropertyIconName(const PropertyName &name) const { - if (name == "Normalize Columns") return "normalise-columns"; - if (name == "Normalize Visible Area") return "normalise"; if (name == "Invert Vertical Scale") return "invert-vertical"; - if (name == "Show Rectified") return "derivative"; if (name == "Opaque") return "opaque"; if (name == "Smooth") return "smooth"; return ""; @@ -201,10 +276,7 @@ Colour3DPlotLayer::getPropertyType(const PropertyName &name) const { if (name == "Gain") return RangeProperty; - if (name == "Normalize Columns") return ToggleProperty; - if (name == "Normalize Visible Area") return ToggleProperty; if (name == "Invert Vertical Scale") return ToggleProperty; - if (name == "Show Rectified") return ToggleProperty; if (name == "Opaque") return ToggleProperty; if (name == "Smooth") return ToggleProperty; return ValueProperty; @@ -213,10 +285,8 @@ QString Colour3DPlotLayer::getPropertyGroupName(const PropertyName &name) const { - if (name == "Normalize Columns" || - name == "Normalize Visible Area" || - name == "Colour Scale" || - name == "Show Rectified" || + if (name == "Normalization" || + name == "Colour Scale" || name == "Gain") return tr("Scale"); if (name == "Bin Scale" || name == "Invert Vertical Scale") return tr("Bins"); @@ -252,11 +322,12 @@ } else if (name == "Colour Scale") { + // linear, log, +/-1, abs *min = 0; *max = 3; - *deflt = (int)LinearScale; + *deflt = 0; - val = (int)m_colourScale; + val = convertFromColourScale(m_colourScale); } else if (name == "Colour") { @@ -266,33 +337,24 @@ val = m_colourMap; - } else if (name == "Normalize Columns") { + } else if (name == "Normalization") { + *min = 0; + *max = 3; *deflt = 0; - val = (m_normalizeColumns ? 1 : 0); - } else if (name == "Normalize Visible Area") { - - *deflt = 0; - val = (m_normalizeVisibleArea ? 1 : 0); + val = convertFromColumnNorm(m_normalization, m_normalizeVisibleArea); } else if (name == "Invert Vertical Scale") { *deflt = 0; val = (m_invertVertical ? 1 : 0); - } else if (name == "Show Rectified") { - - if (min) *min = 0; - if (max) *max = 0; - if (deflt) *deflt = 0; - val = (m_rectified ? 1.0 : 0.0); - } else if (name == "Bin Scale") { *min = 0; *max = 1; - *deflt = int(LinearBinScale); + *deflt = int(BinScale::Linear); val = (int)m_binScale; } else if (name == "Opaque") { @@ -328,6 +390,9 @@ case 3: return tr("Absolute"); } } + if (name == "Normalization") { + return ""; // icon only + } if (name == "Bin Scale") { switch (value) { default: @@ -338,6 +403,22 @@ return tr("<unknown>"); } +QString +Colour3DPlotLayer::getPropertyValueIconName(const PropertyName &name, + int value) const +{ + if (name == "Normalization") { + switch(value) { + default: + case 0: return "normalise-none"; + case 1: return "normalise-columns"; + case 2: return "normalise"; + case 3: return "normalise-hybrid"; + } + } + return ""; +} + RangeMapper * Colour3DPlotLayer::getNewPropertyRangeMapper(const PropertyName &name) const { @@ -353,23 +434,11 @@ if (name == "Gain") { setGain(float(pow(10, value/20.0))); } else if (name == "Colour Scale") { - switch (value) { - default: - case 0: setColourScale(LinearScale); break; - case 1: setColourScale(LogScale); break; - case 2: setColourScale(PlusMinusOneScale); break; - case 3: setColourScale(AbsoluteScale); break; - } + setColourScale(convertToColourScale(value)); } else if (name == "Colour") { setColourMap(value); - } else if (name == "Normalize Columns") { - setNormalizeColumns(value ? true : false); - } else if (name == "Normalize Visible Area") { - setNormalizeVisibleArea(value ? true : false); } else if (name == "Invert Vertical Scale") { setInvertVertical(value ? true : false); - } else if (name == "Show Rectified") { - setShowRectified(value > 0.5); } else if (name == "Opaque") { setOpaque(value ? true : false); } else if (name == "Smooth") { @@ -377,19 +446,23 @@ } else if (name == "Bin Scale") { switch (value) { default: - case 0: setBinScale(LinearBinScale); break; - case 1: setBinScale(LogBinScale); break; + case 0: setBinScale(BinScale::Linear); break; + case 1: setBinScale(BinScale::Log); break; } + } else if (name == "Normalization") { + auto n = convertToColumnNorm(value); + setNormalization(n.first); + setNormalizeVisibleArea(n.second); } } void -Colour3DPlotLayer::setColourScale(ColourScale scale) +Colour3DPlotLayer::setColourScale(ColourScaleType scale) { if (m_colourScale == scale) return; m_colourScale = scale; m_colourScaleSet = true; - cacheInvalid(); + invalidateRenderers(); emit layerParametersChanged(); } @@ -398,7 +471,7 @@ { if (m_colourMap == map) return; m_colourMap = map; - cacheInvalid(); + invalidateRenderers(); emit layerParametersChanged(); } @@ -407,7 +480,7 @@ { if (m_gain == gain) return; m_gain = gain; - cacheInvalid(); + invalidateRenderers(); emit layerParametersChanged(); } @@ -422,52 +495,41 @@ { if (m_binScale == binScale) return; m_binScale = binScale; - cacheInvalid(); + invalidateRenderers(); emit layerParametersChanged(); } -Colour3DPlotLayer::BinScale +BinScale Colour3DPlotLayer::getBinScale() const { return m_binScale; } void -Colour3DPlotLayer::setNormalizeColumns(bool n) +Colour3DPlotLayer::setNormalization(ColumnNormalization n) { - if (m_normalizeColumns == n) return; - m_normalizeColumns = n; - cacheInvalid(); + if (m_normalization == n) return; + + m_normalization = n; + invalidateRenderers(); + emit layerParametersChanged(); } -bool -Colour3DPlotLayer::getNormalizeColumns() const +ColumnNormalization +Colour3DPlotLayer::getNormalization() const { - return m_normalizeColumns; -} - -void -Colour3DPlotLayer::setNormalizeHybrid(bool n) -{ - if (m_normalizeHybrid == n) return; - m_normalizeHybrid = n; - cacheInvalid(); - emit layerParametersChanged(); -} - -bool -Colour3DPlotLayer::getNormalizeHybrid() const -{ - return m_normalizeHybrid; + return m_normalization; } void Colour3DPlotLayer::setNormalizeVisibleArea(bool n) { if (m_normalizeVisibleArea == n) return; + m_normalizeVisibleArea = n; - cacheInvalid(); + invalidateRenderers(); + emit layerParametersChanged(); } @@ -482,16 +544,7 @@ { if (m_invertVertical == n) return; m_invertVertical = n; - cacheInvalid(); - emit layerParametersChanged(); -} - -void -Colour3DPlotLayer::setShowRectified(bool show) -{ - if (m_rectified == show) return; - m_rectified = show; - cacheInvalid(); + invalidateRenderers(); emit layerParametersChanged(); } @@ -500,6 +553,7 @@ { if (m_opaque == n) return; m_opaque = n; + invalidateRenderers(); emit layerParametersChanged(); } @@ -508,6 +562,7 @@ { if (m_smooth == n) return; m_smooth = n; + invalidateRenderers(); emit layerParametersChanged(); } @@ -554,16 +609,19 @@ } bool -Colour3DPlotLayer::isLayerScrollable(const LayerGeometryProvider *v) const +Colour3DPlotLayer::isLayerScrollable(const LayerGeometryProvider */* v */) const { if (m_normalizeVisibleArea) { return false; } - if (shouldPaintDenseIn(v)) { - return true; - } - QPoint discard; - return !v->shouldIlluminateLocalFeatures(this, discard); + //!!! ah hang on, if we're potentially rendering incrementally + //!!! they we can't be scrollable + return false; +// if (getRenderer(v)->willRenderOpaque(v)) { +// return true; +// } +// QPoint discard; +// return !v->shouldIlluminateLocalFeatures(this, discard); } bool @@ -608,6 +666,8 @@ m_miny = int(lrint(min)); m_maxy = int(lrint(max)); + invalidateRenderers(); + emit layerParametersChanged(); return true; } @@ -654,6 +714,8 @@ m_maxy = m_miny + dist; if (m_maxy > m_model->getHeight()) m_maxy = m_model->getHeight(); + invalidateRenderers(); + // SVDEBUG << "Colour3DPlotLayer::setVerticalZoomStep(" <<step <<"): after: miny = " << m_miny << ", maxy = " << m_maxy << endl; emit layerParametersChanged(); @@ -669,14 +731,14 @@ } double -Colour3DPlotLayer::getYForBin(LayerGeometryProvider *v, double bin) const +Colour3DPlotLayer::getYForBin(const LayerGeometryProvider *v, double bin) const { double y = bin; if (!m_model) return y; double mn = 0, mx = m_model->getHeight(); getDisplayExtents(mn, mx); double h = v->getPaintHeight(); - if (m_binScale == LinearBinScale) { + if (m_binScale == BinScale::Linear) { y = h - (((bin - mn) * h) / (mx - mn)); } else { double logmin = mn + 1, logmax = mx + 1; @@ -686,21 +748,15 @@ return y; } -int -Colour3DPlotLayer::getIYForBin(LayerGeometryProvider *v, int bin) const -{ - return int(round(getYForBin(v, bin))); -} - double -Colour3DPlotLayer::getBinForY(LayerGeometryProvider *v, double y) const +Colour3DPlotLayer::getBinForY(const LayerGeometryProvider *v, double y) const { double bin = y; if (!m_model) return bin; double mn = 0, mx = m_model->getHeight(); getDisplayExtents(mn, mx); double h = v->getPaintHeight(); - if (m_binScale == LinearBinScale) { + if (m_binScale == BinScale::Linear) { bin = mn + ((h - y) * (mx - mn)) / h; } else { double logmin = mn + 1, logmax = mx + 1; @@ -710,12 +766,6 @@ return bin; } -int -Colour3DPlotLayer::getIBinForY(LayerGeometryProvider *v, int y) const -{ - return int(floor(getBinForY(v, y))); -} - QString Colour3DPlotLayer::getFeatureDescription(LayerGeometryProvider *v, QPoint &pos) const { @@ -818,49 +868,20 @@ int cw = getColourScaleWidth(paint); int ch = h - 20; - if (ch > 20 && m_cache) { + if (ch > 20) { - double min = m_model->getMinimumLevel(); - double max = m_model->getMaximumLevel(); + double min = m_viewMags[v->getId()].getMin(); + double max = m_viewMags[v->getId()].getMax(); - double mmin = min; - double mmax = max; + if (max <= min) max = min + 0.1; - if (m_colourScale == LogScale) { - LogRange::mapRange(mmin, mmax); - } else if (m_colourScale == PlusMinusOneScale) { - mmin = -1.f; - mmax = 1.f; - } else if (m_colourScale == AbsoluteScale) { - if (mmin < 0) { - if (fabs(mmin) > fabs(mmax)) mmax = fabs(mmin); - else mmax = fabs(mmax); - mmin = 0; - } else { - mmin = fabs(mmin); - mmax = fabs(mmax); - } - } - - if (max == min) max = min + 1.f; - if (mmax == mmin) mmax = mmin + 1.f; - paint.setPen(v->getForeground()); paint.drawRect(4, 10, cw - 8, ch+1); for (int y = 0; y < ch; ++y) { double value = ((max - min) * (double(ch-y) - 1.0)) / double(ch) + min; - if (m_colourScale == LogScale) { - value = LogRange::map(value); - } - int pixel = int(((value - mmin) * 256) / (mmax - mmin)); - if (pixel >= 0 && pixel < 256) { - QRgb c = m_cache->color(pixel); - paint.setPen(QColor(qRed(c), qGreen(c), qBlue(c))); - paint.drawLine(5, 11 + y, cw - 5, 11 + y); - } else { - cerr << "WARNING: Colour3DPlotLayer::paintVerticalScale: value " << value << ", mmin " << mmin << ", mmax " << mmax << " leads to invalid pixel " << pixel << endl; - } + paint.setPen(getRenderer(v)->getColour(value)); + paint.drawLine(5, 11 + y, cw - 5, 11 + y); } QString minstr = QString("%1").arg(min); @@ -869,8 +890,12 @@ paint.save(); QFont font = paint.font(); - font.setPixelSize(int(font.pixelSize() * 0.65)); - paint.setFont(font); + if (font.pixelSize() > 0) { + int newSize = int(font.pixelSize() * 0.65); + if (newSize < 6) newSize = 6; + font.setPixelSize(newSize); + paint.setFont(font); + } int msw = paint.fontMetrics().width(maxstr); @@ -880,12 +905,12 @@ paint.setWorldMatrix(m); - v->drawVisibleText(paint, 2, 0, minstr, View::OutlinedText); + PaintAssistant::drawVisibleText(v, paint, 2, 0, minstr, PaintAssistant::OutlinedText); m.translate(ch - msw - 2, 0); paint.setWorldMatrix(m); - v->drawVisibleText(paint, 0, 0, maxstr, View::OutlinedText); + PaintAssistant::drawVisibleText(v, paint, 0, 0, maxstr, PaintAssistant::OutlinedText); paint.restore(); } @@ -957,36 +982,28 @@ { Profiler profiler("Colour3DPlotLayer::getColumn"); - DenseThreeDimensionalModel::Column prev; - if (m_rectified && (col > m_model->getStartFrame())) { - prev = m_model->getColumn(col - 1); + DenseThreeDimensionalModel::Column values = m_model->getColumn(col); + values.resize(m_model->getHeight(), 0.f); + if (m_normalization != ColumnNormalization::Max1 && + m_normalization != ColumnNormalization::Hybrid) { + return values; } - - DenseThreeDimensionalModel::Column values = m_model->getColumn(col); - - if (m_rectified && !prev.empty()) { - for (int y = 0; y < values.size(); ++y) { - if (values[y] < prev[y]) values[y] = 0; - else values[y] -= prev[y]; - } - } - - while (values.size() < m_model->getHeight()) values.push_back(0.f); - if (!m_normalizeColumns && !m_normalizeHybrid) return values; double colMax = 0.f, colMin = 0.f; double min = 0.f, max = 0.f; + int nv = int(values.size()); + min = m_model->getMinimumLevel(); max = m_model->getMaximumLevel(); - for (int y = 0; y < values.size(); ++y) { + for (int y = 0; y < nv; ++y) { if (y == 0 || values.at(y) > colMax) colMax = values.at(y); if (y == 0 || values.at(y) < colMin) colMin = values.at(y); } if (colMin == colMax) colMax = colMin + 1; - for (int y = 0; y < values.size(); ++y) { + for (int y = 0; y < nv; ++y) { double value = values.at(y); double norm = (value - colMin) / (colMax - colMin); @@ -995,311 +1012,102 @@ if (value != newvalue) values[y] = float(newvalue); } - if (m_normalizeHybrid && (colMax > 0.0)) { + if (m_normalization == ColumnNormalization::Hybrid + && (colMax > 0.0)) { double logmax = log10(colMax); - for (int y = 0; y < values.size(); ++y) { + for (int y = 0; y < nv; ++y) { values[y] = float(values[y] * logmax); } } return values; } - -void -Colour3DPlotLayer::fillCache(int firstBin, int lastBin) const + +Colour3DPlotRenderer * +Colour3DPlotLayer::getRenderer(const LayerGeometryProvider *v) const { - Profiler profiler("Colour3DPlotLayer::fillCache", true); + if (m_renderers.find(v->getId()) == m_renderers.end()) { - sv_frame_t modelStart = m_model->getStartFrame(); - sv_frame_t modelEnd = m_model->getEndFrame(); - int modelResolution = m_model->getResolution(); + Colour3DPlotRenderer::Sources sources; + sources.verticalBinLayer = this; + sources.fft = 0; + sources.source = m_model; + sources.peaks = getPeakCache(); - int modelStartBin = int(modelStart / modelResolution); - int modelEndBin = int(modelEnd / modelResolution); + ColourScale::Parameters cparams; + cparams.colourMap = m_colourMap; + cparams.scaleType = m_colourScale; + cparams.gain = m_gain; -#ifdef DEBUG_COLOUR_3D_PLOT_LAYER_PAINT - cerr << "Colour3DPlotLayer::fillCache: range " << firstBin << " -> " << lastBin << " of model range " << modelStartBin << " -> " << modelEndBin << " (model resolution " << modelResolution << ")" << endl; -#endif + if (m_normalization == ColumnNormalization::None) { + cparams.minValue = m_model->getMinimumLevel(); + cparams.maxValue = m_model->getMaximumLevel(); + } else if (m_normalization == ColumnNormalization::Hybrid) { + cparams.minValue = 0; + cparams.maxValue = log10(m_model->getMaximumLevel() + 1.0); + } - int cacheWidth = modelEndBin - modelStartBin + 1; - if (lastBin > modelEndBin) cacheWidth = lastBin - modelStartBin + 1; - int cacheHeight = m_model->getHeight(); + if (cparams.maxValue <= cparams.minValue) { + cparams.maxValue = cparams.minValue + 0.1; + } + + Colour3DPlotRenderer::Parameters params; + params.colourScale = ColourScale(cparams); + params.normalization = m_normalization; + params.binScale = m_binScale; + params.alwaysOpaque = m_opaque; + params.invertVertical = m_invertVertical; + params.interpolate = m_smooth; - if (m_cache && m_cache->height() != cacheHeight) { - // height has changed: delete everything rather than resizing -#ifdef DEBUG_COLOUR_3D_PLOT_LAYER_PAINT - cerr << "Colour3DPlotLayer::fillCache: Cache height has changed, recreating" << endl; -#endif - delete m_cache; - delete m_peaksCache; - m_cache = 0; - m_peaksCache = 0; - } - - if (m_cache && m_cache->width() != cacheWidth) { - // width has changed and we have an existing cache: resize it -#ifdef DEBUG_COLOUR_3D_PLOT_LAYER_PAINT - cerr << "Colour3DPlotLayer::fillCache: Cache width has changed, resizing existing cache" << endl; -#endif - QImage *newCache = - new QImage(m_cache->copy(0, 0, cacheWidth, cacheHeight)); - delete m_cache; - m_cache = newCache; - if (m_peaksCache) { - QImage *newPeaksCache = - new QImage(m_peaksCache->copy - (0, 0, cacheWidth / m_peakResolution + 1, cacheHeight)); - delete m_peaksCache; - m_peaksCache = newPeaksCache; - } + m_renderers[v->getId()] = new Colour3DPlotRenderer(sources, params); } - if (!m_cache) { -#ifdef DEBUG_COLOUR_3D_PLOT_LAYER_PAINT - cerr << "Colour3DPlotLayer::fillCache: Have no cache, making one" << endl; -#endif - m_cache = new QImage - (cacheWidth, cacheHeight, QImage::Format_Indexed8); - m_cache->setColorCount(256); - m_cache->fill(0); - if (!m_normalizeVisibleArea) { - m_peaksCache = new QImage - (cacheWidth / m_peakResolution + 1, cacheHeight, - QImage::Format_Indexed8); - m_peaksCache->setColorCount(256); - m_peaksCache->fill(0); - } else if (m_peaksCache) { - delete m_peaksCache; - m_peaksCache = 0; - } - m_cacheValidStart = 0; - m_cacheValidEnd = 0; - } + return m_renderers[v->getId()]; +} -#ifdef DEBUG_COLOUR_3D_PLOT_LAYER_PAINT - cerr << "cache size = " << m_cache->width() << "x" << m_cache->height() - << " peaks cache size = " << m_peaksCache->width() << "x" << m_peaksCache->height() << endl; -#endif +void +Colour3DPlotLayer::paintWithRenderer(LayerGeometryProvider *v, + QPainter &paint, QRect rect) const +{ + Colour3DPlotRenderer *renderer = getRenderer(v); - if (m_cacheValidStart <= firstBin && m_cacheValidEnd >= lastBin) { -#ifdef DEBUG_COLOUR_3D_PLOT_LAYER_PAINT - cerr << "Cache is valid in this region already" << endl; -#endif - return; + Colour3DPlotRenderer::RenderResult result; + MagnitudeRange magRange; + int viewId = v->getId(); + + if (!renderer->geometryChanged(v)) { + magRange = m_viewMags[viewId]; } - int fillStart = firstBin; - int fillEnd = lastBin; + if (m_synchronous) { - if (fillStart < modelStartBin) fillStart = modelStartBin; - if (fillStart > modelEndBin) fillStart = modelEndBin; - if (fillEnd < modelStartBin) fillEnd = modelStartBin; - if (fillEnd > modelEndBin) fillEnd = modelEndBin; - - bool normalizeVisible = (m_normalizeVisibleArea && !m_normalizeColumns); - - if (!normalizeVisible && (m_cacheValidStart < m_cacheValidEnd)) { - - if (m_cacheValidEnd < fillStart) { - fillStart = m_cacheValidEnd + 1; - } - if (m_cacheValidStart > fillEnd) { - fillEnd = m_cacheValidStart - 1; - } - - m_cacheValidStart = std::min(fillStart, m_cacheValidStart); - m_cacheValidEnd = std::max(fillEnd, m_cacheValidEnd); + result = renderer->render(v, paint, rect); } else { - // when normalising the visible area, the only valid area, - // ever, is the currently visible one + result = renderer->renderTimeConstrained(v, paint, rect); - m_cacheValidStart = fillStart; - m_cacheValidEnd = fillEnd; - } - -#ifdef DEBUG_COLOUR_3D_PLOT_LAYER_PAINT - cerr << "Cache size " << cacheWidth << "x" << cacheHeight << " will be valid from " << m_cacheValidStart << " to " << m_cacheValidEnd << " (fillStart = " << fillStart << ", fillEnd = " << fillEnd << ")" << endl; -#endif - - DenseThreeDimensionalModel::Column values; - - double min = m_model->getMinimumLevel(); - double max = m_model->getMaximumLevel(); - - if (m_colourScale == LogScale) { - LogRange::mapRange(min, max); - } else if (m_colourScale == PlusMinusOneScale) { - min = -1.f; - max = 1.f; - } else if (m_colourScale == AbsoluteScale) { - if (min < 0) { - if (fabs(min) > fabs(max)) max = fabs(min); - else max = fabs(max); - min = 0; - } else { - min = fabs(min); - max = fabs(max); + QRect uncached = renderer->getLargestUncachedRect(v); + if (uncached.width() > 0) { + v->updatePaintRect(uncached); } } - if (max == min) max = min + 1.f; - - ColourMapper mapper(m_colourMap, 0.f, 255.f); - - for (int index = 0; index < 256; ++index) { - QColor colour = mapper.map(index); - m_cache->setColor - (index, qRgb(colour.red(), colour.green(), colour.blue())); - if (m_peaksCache) { - m_peaksCache->setColor - (index, qRgb(colour.red(), colour.green(), colour.blue())); + magRange.sample(result.range); + + if (magRange.isSet()) { + if (!(m_viewMags[viewId] == magRange)) { + m_viewMags[viewId] = magRange; + //!!! now need to do the normalise-visible thing } } - double visibleMax = 0.f, visibleMin = 0.f; - - if (normalizeVisible) { + cerr << "mag range in this view: " + << m_viewMags[v->getId()].getMin() + << " -> " + << m_viewMags[v->getId()].getMax() + << endl; - for (int c = fillStart; c <= fillEnd; ++c) { - - values = getColumn(c); - - double colMax = 0.f, colMin = 0.f; - - for (int y = 0; y < cacheHeight; ++y) { - if (y >= values.size()) break; - if (y == 0 || values[y] > colMax) colMax = values[y]; - if (y == 0 || values[y] < colMin) colMin = values[y]; - } - - if (c == fillStart || colMax > visibleMax) visibleMax = colMax; - if (c == fillStart || colMin < visibleMin) visibleMin = colMin; - } - - if (m_colourScale == LogScale) { - visibleMin = LogRange::map(visibleMin); - visibleMax = LogRange::map(visibleMax); - if (visibleMin > visibleMax) std::swap(visibleMin, visibleMax); - } else if (m_colourScale == AbsoluteScale) { - if (visibleMin < 0) { - if (fabs(visibleMin) > fabs(visibleMax)) visibleMax = fabs(visibleMin); - else visibleMax = fabs(visibleMax); - visibleMin = 0; - } else { - visibleMin = fabs(visibleMin); - visibleMax = fabs(visibleMax); - } - } - } - - if (visibleMin == visibleMax) visibleMax = visibleMin + 1; - - int *peaks = 0; - if (m_peaksCache) { - peaks = new int[cacheHeight]; - for (int y = 0; y < cacheHeight; ++y) { - peaks[y] = 0; - } - } - - Profiler profiler2("Colour3DPlotLayer::fillCache: filling", true); - - for (int c = fillStart; c <= fillEnd; ++c) { - - values = getColumn(c); - - if (c >= m_cache->width()) { - cerr << "ERROR: column " << c << " >= cache width " - << m_cache->width() << endl; - continue; - } - - for (int y = 0; y < cacheHeight; ++y) { - - double value = min; - if (y < values.size()) { - value = values.at(y); - } - - value = value * m_gain; - - if (m_colourScale == LogScale) { - value = LogRange::map(value); - } else if (m_colourScale == AbsoluteScale) { - value = fabs(value); - } - - if (normalizeVisible) { - double norm = (value - visibleMin) / (visibleMax - visibleMin); - value = min + (max - min) * norm; - } - - int pixel = int(((value - min) * 256) / (max - min)); - if (pixel < 0) pixel = 0; - if (pixel > 255) pixel = 255; - if (peaks && (pixel > peaks[y])) peaks[y] = pixel; - - if (m_invertVertical) { - m_cache->setPixel(c, cacheHeight - y - 1, pixel); - } else { - if (y >= m_cache->height()) { - cerr << "ERROR: row " << y << " >= cache height " << m_cache->height() << endl; - } else { - m_cache->setPixel(c, y, pixel); - } - } - } - - if (peaks) { - int notch = (c % m_peakResolution); - if (notch == m_peakResolution-1 || c == fillEnd) { - int pc = c / m_peakResolution; - if (pc >= m_peaksCache->width()) { - cerr << "ERROR: peak column " << pc - << " (from col " << c << ") >= peaks cache width " - << m_peaksCache->width() << endl; - continue; - } - for (int y = 0; y < cacheHeight; ++y) { - if (m_invertVertical) { - m_peaksCache->setPixel(pc, cacheHeight - y - 1, peaks[y]); - } else { - if (y >= m_peaksCache->height()) { - cerr << "ERROR: row " << y - << " >= peaks cache height " - << m_peaksCache->height() << endl; - } else { - m_peaksCache->setPixel(pc, y, peaks[y]); - } - } - } - for (int y = 0; y < cacheHeight; ++y) { - peaks[y] = 0; - } - } - } - } - - delete[] peaks; -} - -bool -Colour3DPlotLayer::shouldPaintDenseIn(const LayerGeometryProvider *v) const -{ - if (!m_model || !v || !(v->getViewManager())) { - return false; - } - double srRatio = - v->getViewManager()->getMainModelSampleRate() / m_model->getSampleRate(); - if (m_opaque || - m_smooth || - m_model->getHeight() >= v->getPaintHeight() || - ((m_model->getResolution() * srRatio) / v->getZoomLevel()) < 2) { - return true; - } - return false; } void @@ -1324,374 +1132,25 @@ return; } - if (m_normalizeVisibleArea && !m_normalizeColumns) rect = v->getPaintRect(); - - sv_frame_t modelStart = m_model->getStartFrame(); - sv_frame_t modelEnd = m_model->getEndFrame(); - int modelResolution = m_model->getResolution(); - - // The cache is from the model's start frame to the model's end - // frame at the model's window increment frames per pixel. We - // want to draw from our start frame + x0 * zoomLevel to our start - // frame + x1 * zoomLevel at zoomLevel frames per pixel. - - // We have quite different paint mechanisms for rendering "large" - // bins (more than one bin per pixel in both directions) and - // "small". This is "large"; see paintDense below for "small". - - int x0 = rect.left(); - int x1 = rect.right() + 1; - - int h = v->getPaintHeight(); - - double srRatio = - v->getViewManager()->getMainModelSampleRate() / m_model->getSampleRate(); - - int sx0 = int((double(v->getFrameForX(x0)) / srRatio - double(modelStart)) - / modelResolution); - int sx1 = int((double(v->getFrameForX(x1)) / srRatio - double(modelStart)) - / modelResolution); - int sh = m_model->getHeight(); - - int symin = m_miny; - int symax = m_maxy; - if (symax <= symin) { - symin = 0; - symax = sh; - } - if (symin < 0) symin = 0; - if (symax > sh) symax = sh; - - if (sx0 > 0) --sx0; - fillCache(sx0 < 0 ? 0 : sx0, - sx1 < 0 ? 0 : sx1); - + if (m_model->getWidth() == 0) { #ifdef DEBUG_COLOUR_3D_PLOT_LAYER_PAINT - cerr << "Colour3DPlotLayer::paint: height = "<< m_model->getHeight() << ", modelStart = " << modelStart << ", resolution = " << modelResolution << ", model rate = " << m_model->getSampleRate() << " (zoom level = " << v->getZoomLevel() << ", srRatio = " << srRatio << ")" << endl; + cerr << "Colour3DPlotLayer::paint(): model width == 0, " + << "nothing to paint (yet)" << endl; #endif - - if (shouldPaintDenseIn(v)) { -#ifdef DEBUG_COLOUR_3D_PLOT_LAYER_PAINT - cerr << "calling paintDense" << endl; -#endif - paintDense(v, paint, rect); return; } -#ifdef DEBUG_COLOUR_3D_PLOT_LAYER_PAINT - cerr << "Colour3DPlotLayer::paint: w " << x1-x0 << ", h " << h << ", sx0 " << sx0 << ", sx1 " << sx1 << ", sw " << sx1-sx0 << ", sh " << sh << endl; - cerr << "Colour3DPlotLayer: sample rate is " << m_model->getSampleRate() << ", resolution " << m_model->getResolution() << endl; -#endif - - QPoint illuminatePos; - bool illuminate = v->shouldIlluminateLocalFeatures(this, illuminatePos); + //!!!??? - const int buflen = 40; - char labelbuf[buflen]; - - for (int sx = sx0; sx <= sx1; ++sx) { - - sv_frame_t fx = sx * modelResolution; - - if (fx + modelResolution <= modelStart || fx > modelEnd) continue; - - int rx0 = v->getXForFrame(int(double(fx + modelStart) * srRatio)); - int rx1 = v->getXForFrame(int(double(fx + modelStart + modelResolution + 1) * srRatio)); - - int rw = rx1 - rx0; - if (rw < 1) rw = 1; - - bool showLabel = (rw > 10 && - paint.fontMetrics().width("0.000000") < rw - 3 && - paint.fontMetrics().height() < (h / sh)); - - for (int sy = symin; sy < symax; ++sy) { - - int ry0 = getIYForBin(v, sy); - int ry1 = getIYForBin(v, sy + 1); - QRect r(rx0, ry1, rw, ry0 - ry1); - - QRgb pixel = qRgb(255, 255, 255); - if (sx >= 0 && sx < m_cache->width() && - sy >= 0 && sy < m_cache->height()) { - pixel = m_cache->pixel(sx, sy); - } - - if (rw == 1) { - paint.setPen(pixel); - paint.setBrush(Qt::NoBrush); - paint.drawLine(r.x(), r.y(), r.x(), r.y() + r.height() - 1); - continue; - } - - QColor pen(255, 255, 255, 80); - QColor brush(pixel); - - if (rw > 3 && r.height() > 3) { - brush.setAlpha(160); - } - - paint.setPen(Qt::NoPen); - paint.setBrush(brush); - - if (illuminate) { - if (r.contains(illuminatePos)) { - paint.setPen(v->getForeground()); - } - } - -#ifdef DEBUG_COLOUR_3D_PLOT_LAYER_PAINT -// cerr << "rect " << r.x() << "," << r.y() << " " -// << r.width() << "x" << r.height() << endl; -#endif - - paint.drawRect(r); - - if (showLabel) { - if (sx >= 0 && sx < m_cache->width() && - sy >= 0 && sy < m_cache->height()) { - double value = m_model->getValueAt(sx, sy); - snprintf(labelbuf, buflen, "%06f", value); - QString text(labelbuf); - paint.setPen(v->getBackground()); - paint.drawText(rx0 + 2, - ry0 - h / sh - 1 + 2 + paint.fontMetrics().ascent(), - text); - } - } - } - } -} - -void -Colour3DPlotLayer::paintDense(LayerGeometryProvider *v, QPainter &paint, QRect rect) const -{ - Profiler profiler("Colour3DPlotLayer::paintDense", true); - if (!m_cache) return; - - double modelStart = double(m_model->getStartFrame()); - double modelResolution = double(m_model->getResolution()); - - sv_samplerate_t mmsr = v->getViewManager()->getMainModelSampleRate(); - sv_samplerate_t msr = m_model->getSampleRate(); - double srRatio = mmsr / msr; - - int x0 = rect.left(); - int x1 = rect.right() + 1; - - const int w = x1 - x0; // const so it can be used as array size below - int h = v->getPaintHeight(); // we always paint full height - int sh = m_model->getHeight(); - - int symin = m_miny; - int symax = m_maxy; - if (symax <= symin) { - symin = 0; - symax = sh; - } - if (symin < 0) symin = 0; - if (symax > sh) symax = sh; - - QImage img(w, h, QImage::Format_Indexed8); - img.setColorTable(m_cache->colorTable()); - - uchar *peaks = new uchar[w]; - memset(peaks, 0, w); - - int zoomLevel = v->getZoomLevel(); - - QImage *source = m_cache; - -#ifdef DEBUG_COLOUR_3D_PLOT_LAYER_PAINT - cerr << "modelResolution " << modelResolution << ", srRatio " - << srRatio << ", m_peakResolution " << m_peakResolution - << ", zoomLevel " << zoomLevel << ", result " - << ((modelResolution * srRatio * m_peakResolution) / zoomLevel) - << endl; -#endif - - if (m_peaksCache) { - if (((modelResolution * srRatio * m_peakResolution) / zoomLevel) < 1) { -#ifdef DEBUG_COLOUR_3D_PLOT_LAYER_PAINT - cerr << "using peaks cache" << endl; -#endif - source = m_peaksCache; - modelResolution *= m_peakResolution; - } else { -#ifdef DEBUG_COLOUR_3D_PLOT_LAYER_PAINT - cerr << "not using peaks cache" << endl; -#endif - } - } else { -#ifdef DEBUG_COLOUR_3D_PLOT_LAYER_PAINT - cerr << "have no peaks cache" << endl; -#endif + if (m_normalizeVisibleArea) { + rect = v->getPaintRect(); } - int sw = source->width(); - - sv_frame_t xf = -1; - sv_frame_t nxf = v->getFrameForX(x0); + //!!! why is the setLayerDormant(false) found here in + //!!! SpectrogramLayer not present in Colour3DPlotLayer? + //!!! unnecessary? vestigial? forgotten? - double epsilon = 0.000001; - - vector<double> sxa(w*2); - - for (int x = 0; x < w; ++x) { - - xf = nxf; - nxf = xf + zoomLevel; - - double sx0 = (double(xf) / srRatio - modelStart) / modelResolution; - double sx1 = (double(nxf) / srRatio - modelStart) / modelResolution; - - sxa[x*2] = sx0; - sxa[x*2 + 1] = sx1; - } - - double logmin = symin+1, logmax = symax+1; - LogRange::mapRange(logmin, logmax); - -#ifdef DEBUG_COLOUR_3D_PLOT_LAYER_PAINT - cerr << "m_smooth = " << m_smooth << ", w = " << w << ", h = " << h << endl; -#endif - - if (m_smooth) { - - for (int y = 0; y < h; ++y) { - - double sy = getBinForY(v, y) - 0.5; - int syi = int(sy + epsilon); - if (syi < 0 || syi >= source->height()) continue; - - uchar *targetLine = img.scanLine(y); - uchar *sourceLine = source->scanLine(syi); - uchar *nextSource; - if (syi + 1 < source->height()) { - nextSource = source->scanLine(syi + 1); - } else { - nextSource = sourceLine; - } - - for (int x = 0; x < w; ++x) { - - targetLine[x] = 0; - - double sx0 = sxa[x*2]; - if (sx0 < 0) continue; - int sx0i = int(sx0 + epsilon); - if (sx0i >= sw) break; - - double a = sourceLine[sx0i]; - double b = a; - double value; - - double sx1 = sxa[x*2+1]; - if (sx1 > sx0 + 1.f) { - int sx1i = int(sx1); - bool have = false; - for (int sx = sx0i; sx <= sx1i; ++sx) { - if (sx < 0 || sx >= sw) continue; - if (!have) { - a = sourceLine[sx]; - b = nextSource[sx]; - have = true; - } else { - a = std::max(a, double(sourceLine[sx])); - b = std::max(b, double(nextSource[sx])); - } - } - double yprop = sy - syi; - value = (a * (1.f - yprop) + b * yprop); - } else { - a = sourceLine[sx0i]; - b = nextSource[sx0i]; - double yprop = sy - syi; - value = (a * (1.f - yprop) + b * yprop); - int oi = sx0i + 1; - double xprop = sx0 - sx0i; - xprop -= 0.5; - if (xprop < 0) { - oi = sx0i - 1; - xprop = -xprop; - } - if (oi < 0 || oi >= sw) oi = sx0i; - a = sourceLine[oi]; - b = nextSource[oi]; - value = (value * (1.f - xprop) + - (a * (1.f - yprop) + b * yprop) * xprop); - } - - int vi = int(lrint(value)); - if (vi > 255) vi = 255; - if (vi < 0) vi = 0; - targetLine[x] = uchar(vi); - } - } - } else { - - double sy0 = getBinForY(v, 0); - - int psy0i = -1, psy1i = -1; - - for (int y = 0; y < h; ++y) { - - double sy1 = sy0; - sy0 = getBinForY(v, double(y + 1)); - - int sy0i = int(sy0 + epsilon); - int sy1i = int(sy1); - - uchar *targetLine = img.scanLine(y); - - if (sy0i == psy0i && sy1i == psy1i) { - // same source scan line as just computed - goto copy; - } - - psy0i = sy0i; - psy1i = sy1i; - - for (int x = 0; x < w; ++x) { - peaks[x] = 0; - } - - for (int sy = sy0i; sy <= sy1i; ++sy) { - - if (sy < 0 || sy >= source->height()) continue; - - uchar *sourceLine = source->scanLine(sy); - - for (int x = 0; x < w; ++x) { - - double sx1 = sxa[x*2 + 1]; - if (sx1 < 0) continue; - int sx1i = int(sx1); - - double sx0 = sxa[x*2]; - if (sx0 < 0) continue; - int sx0i = int(sx0 + epsilon); - if (sx0i >= sw) break; - - uchar peak = 0; - for (int sx = sx0i; sx <= sx1i; ++sx) { - if (sx < 0 || sx >= sw) continue; - if (sourceLine[sx] > peak) peak = sourceLine[sx]; - } - peaks[x] = peak; - } - } - - copy: - for (int x = 0; x < w; ++x) { - targetLine[x] = peaks[x]; - } - } - } - - delete[] peaks; - - paint.drawImage(x0, 0, img); + paintWithRenderer(v, paint, rect); } bool @@ -1726,25 +1185,40 @@ { QString s = QString("scale=\"%1\" " "colourScheme=\"%2\" " - "normalizeColumns=\"%3\" " - "normalizeVisibleArea=\"%4\" " - "minY=\"%5\" " - "maxY=\"%6\" " - "invertVertical=\"%7\" " - "opaque=\"%8\" %9") - .arg((int)m_colourScale) + "minY=\"%3\" " + "maxY=\"%4\" " + "invertVertical=\"%5\" " + "opaque=\"%6\" %7") + .arg(convertFromColourScale(m_colourScale)) .arg(m_colourMap) - .arg(m_normalizeColumns ? "true" : "false") - .arg(m_normalizeVisibleArea ? "true" : "false") .arg(m_miny) .arg(m_maxy) .arg(m_invertVertical ? "true" : "false") .arg(m_opaque ? "true" : "false") .arg(QString("binScale=\"%1\" smooth=\"%2\" gain=\"%3\" ") - .arg((int)m_binScale) + .arg(int(m_binScale)) .arg(m_smooth ? "true" : "false") .arg(m_gain)); + // New-style normalization attributes, allowing for more types of + // 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 == ColumnNormalization::Max1 ? "peak" : + m_normalization == ColumnNormalization::Hybrid ? "hybrid" : "none"); + + // Old-style normalization attribute, for backward compatibility + + s += QString("normalizeColumns=\"%1\" ") + .arg(m_normalization == ColumnNormalization::Max1 ? "true" : "false"); + + // And this applies to both old- and new-style attributes + + s += QString("normalizeVisibleArea=\"%1\" ") + .arg(m_normalizeVisibleArea ? "true" : "false"); + Layer::toXml(stream, indent, extraAttributes + " " + s); } @@ -1753,22 +1227,16 @@ { bool ok = false, alsoOk = false; - ColourScale scale = (ColourScale)attributes.value("scale").toInt(&ok); - if (ok) setColourScale(scale); + ColourScaleType colourScale = convertToColourScale + (attributes.value("colourScale").toInt(&ok)); + if (ok) setColourScale(colourScale); int colourMap = attributes.value("colourScheme").toInt(&ok); if (ok) setColourMap(colourMap); - BinScale binscale = (BinScale)attributes.value("binScale").toInt(&ok); - if (ok) setBinScale(binscale); - - bool normalizeColumns = - (attributes.value("normalizeColumns").trimmed() == "true"); - setNormalizeColumns(normalizeColumns); - - bool normalizeVisibleArea = - (attributes.value("normalizeVisibleArea").trimmed() == "true"); - setNormalizeVisibleArea(normalizeVisibleArea); + BinScale binScale = (BinScale) + attributes.value("binScale").toInt(&ok); + if (ok) setBinScale(binScale); bool invertVertical = (attributes.value("invertVertical").trimmed() == "true"); @@ -1788,5 +1256,50 @@ float min = attributes.value("minY").toFloat(&ok); float max = attributes.value("maxY").toFloat(&alsoOk); if (ok && alsoOk) setDisplayExtents(min, max); + + bool haveNewStyleNormalization = false; + + QString columnNormalization = attributes.value("columnNormalization"); + + if (columnNormalization != "") { + + haveNewStyleNormalization = true; + + if (columnNormalization == "peak") { + setNormalization(ColumnNormalization::Max1); + } else if (columnNormalization == "hybrid") { + setNormalization(ColumnNormalization::Hybrid); + } else if (columnNormalization == "none") { + setNormalization(ColumnNormalization::None); + } else { + cerr << "NOTE: Unknown or unsupported columnNormalization attribute \"" + << columnNormalization << "\"" << endl; + } + } + + if (!haveNewStyleNormalization) { + + setNormalization(ColumnNormalization::None); + + bool normalizeColumns = + (attributes.value("normalizeColumns").trimmed() == "true"); + if (normalizeColumns) { + setNormalization(ColumnNormalization::Max1); + } + + bool normalizeHybrid = + (attributes.value("normalizeHybrid").trimmed() == "true"); + if (normalizeHybrid) { + setNormalization(ColumnNormalization::Hybrid); + } + } + + bool normalizeVisibleArea = + (attributes.value("normalizeVisibleArea").trimmed() == "true"); + setNormalizeVisibleArea(normalizeVisibleArea); + + //!!! todo: check save/reload scaling, compare with + //!!! SpectrogramLayer, compare with prior SV versions, compare + //!!! with Tony v1 and v2 and their save files }