comparison layer/Colour3DPlotLayer.cpp @ 1235:dd3901fe8623

Wire up normalise-visible-area mode in colour 3d plot

 
     delete m_peakCache;
     m_peakCache = 0;
 
     invalidateRenderers();
+    invalidateMagnitudes();
 
     emit modelReplaced();
     emit sliceableModelReplaced(oldModel, model);
 }
 
 void
 Colour3DPlotLayer::cacheInvalid()
 {
     invalidateRenderers();
+    invalidateMagnitudes();
 }
 
 void
 Colour3DPlotLayer::cacheInvalid(sv_frame_t /* startFrame */,
                                 sv_frame_t /* endFrame */)

     //!!! should do this only if the range is visible
     delete m_peakCache;
     m_peakCache = 0;
     
     invalidateRenderers();
+    invalidateMagnitudes();
 }
 
 void
 Colour3DPlotLayer::invalidateRenderers()
 {
     for (ViewRendererMap::iterator i = m_renderers.begin();
          i != m_renderers.end(); ++i) {
         delete i->second;
     }
     m_renderers.clear();
+}
+
+void
+Colour3DPlotLayer::invalidateMagnitudes()
+{
+#ifdef DEBUG_COLOUR_3D_PLOT_LAYER_PAINT
+    cerr << "Colour3DPlotLayer::invalidateMagnitudes called" << endl;
+#endif
+    m_viewMags.clear();
 }
 
 Dense3DModelPeakCache *
 Colour3DPlotLayer::getPeakCache() const
 {

 void
 Colour3DPlotLayer::setNormalizeVisibleArea(bool n)
 {
     if (m_normalizeVisibleArea == n) return;
 
+    invalidateRenderers();
+    invalidateMagnitudes();
     m_normalizeVisibleArea = n;
-    invalidateRenderers();
     
     emit layerParametersChanged();
 }
 
 bool

 }
 
 bool
 Colour3DPlotLayer::isLayerScrollable(const LayerGeometryProvider * /* v */) const
 {
-    if (m_normalizeVisibleArea) {
-        return false;
-    }
-    //!!! 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
 Colour3DPlotLayer::getValueExtents(double &min, double &max,
                                    bool &logarithmic, QString &unit) const

 }
 
 Colour3DPlotRenderer *
 Colour3DPlotLayer::getRenderer(const LayerGeometryProvider *v) const
 {
-    if (m_renderers.find(v->getId()) == m_renderers.end()) {
+    int viewId = v->getId();
+    
+    if (m_renderers.find(viewId) == m_renderers.end()) {
 
         Colour3DPlotRenderer::Sources sources;
         sources.verticalBinLayer = this;
         sources.fft = 0;
         sources.source = m_model;

         ColourScale::Parameters cparams;
         cparams.colourMap = m_colourMap;
         cparams.scaleType = m_colourScale;
         cparams.gain = m_gain;
 
-        if (m_normalization == ColumnNormalization::None) {
-            cparams.minValue = m_model->getMinimumLevel();
-            cparams.maxValue = m_model->getMaximumLevel();
+        double minValue = 0.0;
+        double maxValue = 1.0;
+        
+        if (m_normalizeVisibleArea && m_viewMags[viewId].isSet()) {
+            minValue = m_viewMags[viewId].getMin();
+            maxValue = m_viewMags[viewId].getMax();
+        } else if (m_normalization == ColumnNormalization::None) {
+            minValue = m_model->getMinimumLevel();
+            maxValue = m_model->getMaximumLevel();
         } else if (m_normalization == ColumnNormalization::Hybrid) {
-            cparams.minValue = 0;
-            cparams.maxValue = log10(m_model->getMaximumLevel() + 1.0);
-        }
-
-        if (cparams.maxValue <= cparams.minValue) {
-            cparams.maxValue = cparams.minValue + 0.1;
-        }
+            minValue = 0;
+            maxValue = log10(m_model->getMaximumLevel() + 1.0);
+        }
+
+        if (maxValue <= minValue) {
+            maxValue = minValue + 0.1f;
+        }
+
+        cparams.minValue = minValue;
+        cparams.maxValue = maxValue;
         
+        m_lastRenderedMags[viewId] = MagnitudeRange(float(minValue),
+                                                    float(maxValue));
+
         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()];
+        m_renderers[viewId] = new Colour3DPlotRenderer(sources, params);
+    }
+
+    return m_renderers[viewId];
 }
 
 void
 Colour3DPlotLayer::paintWithRenderer(LayerGeometryProvider *v,
                                      QPainter &paint, QRect rect) const

 
     Colour3DPlotRenderer::RenderResult result;
     MagnitudeRange magRange;
     int viewId = v->getId();
 
-    if (!renderer->geometryChanged(v)) {
+    bool continuingPaint = !renderer->geometryChanged(v);
+    
+    if (continuingPaint) {
         magRange = m_viewMags[viewId];
     }
     
     if (m_synchronous) {
 

     }
     
     magRange.sample(result.range);
 
     if (magRange.isSet()) {
-        if (!(m_viewMags[viewId] == magRange)) {
+        if (m_viewMags[viewId] != magRange) {
             m_viewMags[viewId] = magRange;
-    //!!! now need to do the normalise-visible thing
-        }
-    }
-    
-    SVDEBUG << "Colour3DPlotRenderer::paintWithRenderer: mag range in this view: "
-            << m_viewMags[v->getId()].getMin()
-            << " -> "
-            << m_viewMags[v->getId()].getMax()
-            << endl;
+#ifdef DEBUG_COLOUR_3D_PLOT_LAYER_PAINT
+            cerr << "mag range in this view has changed: "
+                 << magRange.getMin() << " -> " << magRange.getMax() << endl;
+#endif
+        }
+    }
+    
+    if (!continuingPaint && m_normalizeVisibleArea &&
+        m_viewMags[viewId] != m_lastRenderedMags[viewId]) {
+#ifdef DEBUG_COLOUR_3D_PLOT_LAYER_PAINT
+        cerr << "mag range has changed from last rendered range: re-rendering"
+             << endl;
+#endif
+        delete m_renderers[viewId];
+        m_renderers.erase(viewId);
+        v->updatePaintRect(v->getPaintRect());
+    }
 }
 
 void
 Colour3DPlotLayer::paint(LayerGeometryProvider *v, QPainter &paint, QRect rect) const
 {

         cerr << "Colour3DPlotLayer::paint(): model width == 0, "
              << "nothing to paint (yet)" << endl;
 #endif
         return;
     }
-
-    //!!!???
-    
-    if (m_normalizeVisibleArea) {
-        rect = v->getPaintRect();
-    }
-
-    //!!! why is the setLayerDormant(false) found here in
-    //!!! SpectrogramLayer not present in Colour3DPlotLayer?
-    //!!! unnecessary? vestigial? forgotten?
 
     paintWithRenderer(v, paint, rect);
 }
 
 bool