comparison layer/Colour3DPlotLayer.cpp @ 1100:102f986ec032 spectrogram-minor-refactor

Create, but don't yet use, a renderer in the colour 3d plot layer

 #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>

     m_invertVertical(false),
     m_opaque(false),
     m_smooth(false),
     m_peakResolution(256),
     m_miny(0),
-    m_maxy(0)
+    m_maxy(0),
+    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;
+    delete m_peaksCache; //!!! this one is to go...
+    delete m_peakCache;
 }
 
 void
 Colour3DPlotLayer::setModel(const DenseThreeDimensionalModel *model)
 {

     } else if (model->getResolution() > 128) {
         m_peakResolution = 64;
     } else if (model->getResolution() > 2) {
         m_peakResolution = 128;
     }
+
+    delete m_peakCache;
+    m_peakCache = 0;
+
     cacheInvalid();
 
     emit modelReplaced();
     emit sliceableModelReplaced(oldModel, model);
 }
 
 void
 Colour3DPlotLayer::cacheInvalid()
 {
+    //!!! to go
+    
     delete m_cache;
     delete m_peaksCache;
     m_cache = 0;
     m_peaksCache = 0;
     m_cacheValidStart = 0;

 }
 
 void
 Colour3DPlotLayer::cacheInvalid(sv_frame_t startFrame, sv_frame_t endFrame)
 {
+    //!!! to go
+    
     if (!m_cache || !m_model) return;
 
     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;
+}
+
+Dense3DModelPeakCache *
+Colour3DPlotLayer::getPeakCache() const
+{
+    if (!m_peakCache) {
+        m_peakCache = new Dense3DModelPeakCache(m_model, m_peakCacheDivisor);
+    }
+    return m_peakCache;
 }
 
 void
 Colour3DPlotLayer::modelChanged()
 {

         m_model->getHeight() >= v->getPaintHeight() ||
         ((m_model->getResolution() * srRatio) / v->getZoomLevel()) < 2) {
         return true;
     }
     return false;
+}
+
+Colour3DPlotRenderer *
+Colour3DPlotLayer::getRenderer(LayerGeometryProvider *v) const
+{
+    if (m_renderers.find(v->getId()) == m_renderers.end()) {
+
+        Colour3DPlotRenderer::Sources sources;
+        sources.verticalBinLayer = this;
+        sources.fft = 0;
+        sources.source = m_model;
+        sources.peaks = getPeakCache();
+
+        ColourScale::Parameters cparams;
+        cparams.colourMap = m_colourMap;
+        cparams.scale = m_colourScale;
+        cparams.gain = m_gain;
+
+        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;
+
+        m_renderers[v->getId()] = new Colour3DPlotRenderer(sources, params);
+    }
+
+    return m_renderers[v->getId()];
 }
 
 void
 Colour3DPlotLayer::paint(LayerGeometryProvider *v, QPainter &paint, QRect rect) const
 {