comparison layer/SliceLayer.cpp @ 1486:ac0a8addabcf

Merge from branch by-id

 #include <QPainterPath>
 #include <QTextStream>
 
 
 SliceLayer::SliceLayer() :
-    m_sliceableModel(nullptr),
     m_binAlignment(BinsSpanScalePoints),
     m_colourMap(int(ColourMapper::Ice)),
     m_colourInverted(false),
     m_energyScale(dBScale),
     m_samplingMode(SampleMean),

 {
 
 }
 
 void
-SliceLayer::setSliceableModel(const Model *model)
-{
-    const DenseThreeDimensionalModel *sliceable =
-        dynamic_cast<const DenseThreeDimensionalModel *>(model);
-
-    if (model && !sliceable) {
-        cerr << "WARNING: SliceLayer::setSliceableModel(" << model
-                  << "): model is not a DenseThreeDimensionalModel" << endl;
-    }
-
-    if (m_sliceableModel == sliceable) return;
-
-    m_sliceableModel = sliceable;
-
-    if (!m_sliceableModel) return;
-
-    connectSignals(m_sliceableModel);
-
-    if (m_minbin == 0 && m_maxbin == 0) {
-        m_minbin = 0;
-        m_maxbin = m_sliceableModel->getHeight();
+SliceLayer::setSliceableModel(ModelId modelId)
+{
+    auto newModel = ModelById::getAs<DenseThreeDimensionalModel>(modelId);
+    
+    if (!modelId.isNone() && !newModel) {
+        throw std::logic_error("Not a DenseThreeDimensionalModel");
+    }
+
+    if (m_sliceableModel == modelId) return;
+    m_sliceableModel = modelId;
+
+    if (newModel) {
+        connectSignals(m_sliceableModel);
+
+        if (m_minbin == 0 && m_maxbin == 0) {
+            m_minbin = 0;
+            m_maxbin = newModel->getHeight();
+        }
     }
     
     emit modelReplaced();
     emit layerParametersChanged();
 }
 
 void
-SliceLayer::sliceableModelReplaced(const Model *orig, const Model *replacement)
+SliceLayer::sliceableModelReplaced(ModelId orig, ModelId replacement)
 {
     SVDEBUG << "SliceLayer::sliceableModelReplaced(" << orig << ", " << replacement << ")" << endl;
 
     if (orig == m_sliceableModel) {
-        setSliceableModel
-            (dynamic_cast<const DenseThreeDimensionalModel *>(replacement));
-    }
-}
-
-void
-SliceLayer::modelAboutToBeDeleted(Model *m)
-{
-    SVDEBUG << "SliceLayer::modelAboutToBeDeleted(" << m << ")" << endl;
-
-    if (m == m_sliceableModel) {
-        setSliceableModel(nullptr);
+        setSliceableModel(replacement);
     }
 }
 
 QString
 SliceLayer::getFeatureDescription(LayerGeometryProvider *v, QPoint &p) const

                                      bool includeBinDescription,
                                      int &minbin, int &maxbin, int &range) const
 {
     minbin = 0;
     maxbin = 0;
-    if (!m_sliceableModel) return "";
+    
+    auto sliceableModel =
+        ModelById::getAs<DenseThreeDimensionalModel>(m_sliceableModel);
+    if (!sliceableModel) return "";
 
     if (m_binAlignment == BinsSpanScalePoints) {
         minbin = int(getBinForX(v, p.x()));
         maxbin = int(getBinForX(v, p.x() + 1));
     } else {
         minbin = int(getBinForX(v, p.x()) + 0.5);
         maxbin = int(getBinForX(v, p.x() + 1) + 0.5);
     }        
 
-    int mh = m_sliceableModel->getHeight();
+    int mh = sliceableModel->getHeight();
     if (minbin >= mh) minbin = mh - 1;
     if (maxbin >= mh) maxbin = mh - 1;
     if (minbin < 0) minbin = 0;
     if (maxbin < 0) maxbin = 0;
     
-    sv_samplerate_t sampleRate = m_sliceableModel->getSampleRate();
+    sv_samplerate_t sampleRate = sliceableModel->getSampleRate();
 
     sv_frame_t f0 = m_currentf0;
     sv_frame_t f1 = m_currentf1;
 
     RealTime rt0 = RealTime::frame2RealTime(f0, sampleRate);

 }
 
 void
 SliceLayer::paint(LayerGeometryProvider *v, QPainter &paint, QRect rect) const
 {
-    if (!m_sliceableModel ||
-        !m_sliceableModel->isOK() ||
-        !m_sliceableModel->isReady()) return;
+    auto sliceableModel =
+        ModelById::getAs<DenseThreeDimensionalModel>(m_sliceableModel);
+    if (!sliceableModel ||
+        !sliceableModel->isOK() ||
+        !sliceableModel->isReady()) return;
 
     Profiler profiler("SliceLayer::paint()");
 
     paint.save();
     paint.setRenderHint(QPainter::Antialiasing, true);

                                rect.width(), m_scalePoints[i] * ratio);
             }
         }
     }
 
-    int mh = m_sliceableModel->getHeight();
+    int mh = sliceableModel->getHeight();
     int bin0 = 0;
     if (m_maxbin > m_minbin) {
         mh = m_maxbin - m_minbin;
         bin0 = m_minbin;
     }

     sv_frame_t f1 = v->getFrameForX(f0x + 1);
     if (f1 > f0) --f1;
 
 //    cerr << "centre frame " << v->getCentreFrame() << ", x " << f0x << ", f0 " << f0 << ", f1 " << f1 << endl;
 
-    int res = m_sliceableModel->getResolution();
+    int res = sliceableModel->getResolution();
     int col0 = int(f0 / res);
     int col1 = col0;
     if (m_samplingMode != NearestSample) col1 = int(f1 / res);
     f0 = col0 * res;
     f1 = (col1 + 1) * res - 1;

     getBiasCurve(curve);
     int cs = int(curve.size());
 
     for (int col = col0; col <= col1; ++col) {
         DenseThreeDimensionalModel::Column column =
-            m_sliceableModel->getColumn(col);
+            sliceableModel->getColumn(col);
         for (int bin = 0; bin < mh; ++bin) {
             float value = column[bin0 + bin];
             if (bin < cs) value *= curve[bin];
             if (m_samplingMode == SamplePeak) {
                 if (value > m_values[bin]) m_values[bin] = value;

 }
 
 int
 SliceLayer::getVerticalScaleWidth(LayerGeometryProvider *, bool, QPainter &paint) const
 {
+    // Qt 5.13 deprecates QFontMetrics::width(), but its suggested
+    // replacement (horizontalAdvance) was only added in Qt 5.11
+    // which is too new for us
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+
     int width;
     if (m_energyScale == LinearScale || m_energyScale == AbsoluteScale) {
         width = std::max(paint.fontMetrics().width("0.0") + 13,
                          paint.fontMetrics().width("x10-10"));
     } else {

 
 bool
 SliceLayer::getValueExtents(double &min, double &max, bool &logarithmic,
                             QString &unit) const
 {
-    if (!m_sliceableModel) return false;
+    auto sliceableModel =
+        ModelById::getAs<DenseThreeDimensionalModel>(m_sliceableModel);
+    if (!sliceableModel) return false;
     
     min = 0;
-    max = double(m_sliceableModel->getHeight());
+    max = double(sliceableModel->getHeight());
 
     logarithmic = (m_binScale == BinScale::LogBins);
     unit = "";
 
     return true;
 }
 
 bool
 SliceLayer::getDisplayExtents(double &min, double &max) const
 {
-    if (!m_sliceableModel) return false;
-
-    double hmax = double(m_sliceableModel->getHeight());
+    auto sliceableModel =
+        ModelById::getAs<DenseThreeDimensionalModel>(m_sliceableModel);
+    if (!sliceableModel) return false;
+
+    double hmax = double(sliceableModel->getHeight());
     
     min = m_minbin;
     max = m_maxbin;
     if (max <= min) {
         min = 0;

 }
 
 bool
 SliceLayer::setDisplayExtents(double min, double max)
 {
-    if (!m_sliceableModel) return false;
+    auto sliceableModel =
+        ModelById::getAs<DenseThreeDimensionalModel>(m_sliceableModel);
+    if (!sliceableModel) return false;
 
     m_minbin = int(lrint(min));
     m_maxbin = int(lrint(max));
 
     if (m_minbin < 0) {
         m_minbin = 0;
     }
     if (m_maxbin < 0) {
         m_maxbin = 0;
     }
-    if (m_minbin > m_sliceableModel->getHeight()) {
-        m_minbin = m_sliceableModel->getHeight();
-    }
-    if (m_maxbin > m_sliceableModel->getHeight()) {
-        m_maxbin = m_sliceableModel->getHeight();
+    if (m_minbin > sliceableModel->getHeight()) {
+        m_minbin = sliceableModel->getHeight();
+    }
+    if (m_maxbin > sliceableModel->getHeight()) {
+        m_maxbin = sliceableModel->getHeight();
     }
     if (m_maxbin < m_minbin) {
         m_maxbin = m_minbin;
     }
 

 }
 
 int
 SliceLayer::getVerticalZoomSteps(int &defaultStep) const
 {
-    if (!m_sliceableModel) return 0;
+    auto sliceableModel =
+        ModelById::getAs<DenseThreeDimensionalModel>(m_sliceableModel);
+    if (!sliceableModel) return 0;
 
     defaultStep = 0;
-    int h = m_sliceableModel->getHeight();
+    int h = sliceableModel->getHeight();
     return h;
 }
 
 int
 SliceLayer::getCurrentVerticalZoomStep() const
 {
-    if (!m_sliceableModel) return 0;
+    auto sliceableModel =
+        ModelById::getAs<DenseThreeDimensionalModel>(m_sliceableModel);
+    if (!sliceableModel) return 0;
 
     double min, max;
     getDisplayExtents(min, max);
-    return m_sliceableModel->getHeight() - int(lrint(max - min));
+    return sliceableModel->getHeight() - int(lrint(max - min));
 }
 
 void
 SliceLayer::setVerticalZoomStep(int step)
 {
-    if (!m_sliceableModel) return;
+    auto sliceableModel =
+        ModelById::getAs<DenseThreeDimensionalModel>(m_sliceableModel);
+    if (!sliceableModel) return;
 
 //    SVDEBUG << "SliceLayer::setVerticalZoomStep(" <<step <<"): before: minbin = " << m_minbin << ", maxbin = " << m_maxbin << endl;
 
-    int dist = m_sliceableModel->getHeight() - step;
+    int dist = sliceableModel->getHeight() - step;
     if (dist < 1) dist = 1;
     double centre = m_minbin + (m_maxbin - m_minbin) / 2.0;
     int minbin = int(lrint(centre - dist/2.0));
     int maxbin = minbin + dist;
     setDisplayExtents(minbin, maxbin);
 }
 
 RangeMapper *
 SliceLayer::getNewVerticalZoomRangeMapper() const
 {
-    if (!m_sliceableModel) return nullptr;
-
-    return new LinearRangeMapper(0, m_sliceableModel->getHeight(),
-                                 0, m_sliceableModel->getHeight(), "");
+    auto sliceableModel =
+        ModelById::getAs<DenseThreeDimensionalModel>(m_sliceableModel);
+    if (!sliceableModel) return nullptr;
+
+    return new LinearRangeMapper(0, sliceableModel->getHeight(),
+                                 0, sliceableModel->getHeight(), "");
 }
 
 void
 SliceLayer::zoomToRegion(const LayerGeometryProvider *v, QRect rect)
 {