comparison layer/Colour3DPlotLayer.cpp @ 1459:42c87368287c

Merge from branch single-point

     m_model = model;
     if (!m_model || !m_model->isOK()) return;
 
     connectSignals(m_model);
 
-    connect(m_model, SIGNAL(modelChanged()), this, SLOT(modelChanged()));
+    connect(m_model, SIGNAL(modelChanged()),
+            this, SLOT(handleModelChanged()));
     connect(m_model, SIGNAL(modelChangedWithin(sv_frame_t, sv_frame_t)),
-            this, SLOT(modelChangedWithin(sv_frame_t, sv_frame_t)));
+            this, SLOT(handleModelChangedWithin(sv_frame_t, sv_frame_t)));
 
     m_peakResolution = 256;
     if (model->getResolution() > 512) {
         m_peakResolution = 16;
     } else if (model->getResolution() > 128) {
         m_peakResolution = 64;
     } else if (model->getResolution() > 2) {
         m_peakResolution = 128;
     }
 
+    invalidatePeakCache();
+
+    emit modelReplaced();
+    emit sliceableModelReplaced(oldModel, model);
+}
+
+void
+Colour3DPlotLayer::invalidatePeakCache()
+{
+    // renderers use the peak cache, so we must invalidate those too
+    invalidateRenderers();
+    invalidateMagnitudes();
+    
     if (m_peakCache) m_peakCache->aboutToDelete();
     delete m_peakCache;
     m_peakCache = nullptr;
-
-    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
-    if (m_peakCache) m_peakCache->aboutToDelete();
-    delete m_peakCache;
-    m_peakCache = nullptr;
-    
-    invalidateRenderers();
-    invalidateMagnitudes();
 }
 
 void
 Colour3DPlotLayer::invalidateRenderers()
 {

     }
     return m_peakCache;
 }
 
 void
-Colour3DPlotLayer::modelChanged()
+Colour3DPlotLayer::handleModelChanged()
 {
     if (!m_colourScaleSet && m_colourScale == ColourScaleType::Linear) {
         if (m_model) {
             if (m_model->shouldUseLogValueScale()) {
                 setColourScale(ColourScaleType::Log);
             } else {
                 m_colourScaleSet = true;
             }
         }
     }
-    cacheInvalid();
-}
-
-void
-Colour3DPlotLayer::modelChangedWithin(sv_frame_t startFrame, sv_frame_t endFrame)
+    invalidatePeakCache();
+    emit modelChanged();
+}
+
+void
+Colour3DPlotLayer::handleModelChangedWithin(sv_frame_t startFrame, sv_frame_t endFrame)
 {
     if (!m_colourScaleSet && m_colourScale == ColourScaleType::Linear) {
         if (m_model && m_model->getWidth() > 50) {
             if (m_model->shouldUseLogValueScale()) {
                 setColourScale(ColourScaleType::Log);
             } else {
                 m_colourScaleSet = true;
             }
         }
     }
-    cacheInvalid(startFrame, endFrame);
+    emit modelChangedWithin(startFrame, endFrame);
 }
 
 Layer::PropertyList
 Colour3DPlotLayer::getProperties() const
 {

 Colour3DPlotLayer::getSmooth() const
 {
     return m_smooth;
 }
 
+bool
+Colour3DPlotLayer::hasLightBackground() const 
+{
+    return ColourMapper(m_colourMap, m_colourInverted, 1.f, 255.f)
+        .hasLightBackground();
+}
+
 void
 Colour3DPlotLayer::setLayerDormant(const LayerGeometryProvider *v, bool dormant)
 {
     if (dormant) {
 

             return;
         }
 
         Layer::setLayerDormant(v, true);
 
-        cacheInvalid();
+        invalidatePeakCache(); // for memory-saving purposes
         
     } else {
 
         Layer::setLayerDormant(v, false);
     }

     sv_frame_t right = left + resolution;
 
     switch (snap) {
     case SnapLeft:  frame = left;  break;
     case SnapRight: frame = right; break;
-    case SnapNearest:
     case SnapNeighbouring:
         if (frame - left > right - frame) frame = right;
         else frame = left;
         break;
     }