comparison layer/Colour3DPlotLayer.cpp @ 1563:563bab925c9b spectrogram-export

Use Colour3DPlotExporter in line with SpectrogramLayer

 #include "base/RangeMapper.h"
 
 #include "ColourMapper.h"
 #include "LayerGeometryProvider.h"
 #include "PaintAssistant.h"
+#include "Colour3DPlotExporter.h"
 
 #include "data/model/Dense3DModelPeakCache.h"
 
 #include "view/ViewManager.h"
 

 }
 
 Colour3DPlotLayer::~Colour3DPlotLayer()
 {
     invalidateRenderers();
+    
+    for (auto exporterId: m_exporters) {
+        if (auto exporter =
+            ModelById::getAs<Colour3DPlotExporter>(exporterId)) {
+            exporter->discardSources();
+        }
+        ModelById::release(exporterId);
+    }
 }
 
 const ZoomConstraint *
 Colour3DPlotLayer::getZoomConstraint() const 
 {

 {
 #ifdef DEBUG_COLOUR_3D_PLOT_LAYER_PAINT
     SVDEBUG << "Colour3DPlotLayer::invalidateMagnitudes called" << endl;
 #endif
     m_viewMags.clear();
+}
+
+ModelId
+Colour3DPlotLayer::getExportModel(LayerGeometryProvider *v) const
+{
+    // Creating Colour3DPlotExporters is cheap, so we create one on
+    // every call - calls probably being infrequent - to avoid having
+    // to worry about view lifecycles.
+
+    auto model = ModelById::getAs<DenseThreeDimensionalModel>(m_model);
+    if (!model) return {};
+    int viewId = v->getId();
+    
+    Colour3DPlotExporter::Sources sources;
+    sources.verticalBinLayer = this;
+    sources.source = m_model;
+    sources.provider = v;
+        
+    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::Hybrid) {
+        minValue = 0;
+        maxValue = log10(model->getMaximumLevel() + 1.0);
+    } else if (m_normalization == ColumnNormalization::None) {
+        minValue = model->getMinimumLevel();
+        maxValue = model->getMaximumLevel();
+    }
+
+    if (maxValue <= minValue) {
+        maxValue = minValue + 0.1f;
+
+        if (!(maxValue > minValue)) { // one of them must be NaN or Inf
+            SVCERR << "WARNING: Colour3DPlotLayer::getExportModel: resetting "
+                   << "minValue and maxValue to zero and one" << endl;
+            minValue = 0.f;
+            maxValue = 1.f;
+        }
+    }
+        
+    Colour3DPlotExporter::Parameters params;
+    params.threshold = minValue;
+    params.gain = m_gain; // matching ColourScale in getRenderer
+    params.normalization = m_normalization;
+    
+    ModelId exporter = ModelById::add
+        (std::make_shared<Colour3DPlotExporter>(sources, params));
+    m_exporters.push_back(exporter);
+    return exporter;
 }
 
 ModelId
 Colour3DPlotLayer::getPeakCache() const
 {