comparison layer/Colour3DPlotLayer.cpp @ 1103:d84a0033b305 spectrogram-minor-refactor

Turn BinDisplay and BinScale into enum classes

     m_cacheValidEnd(0),
     m_colourScale(ColourScale::LinearColourScale),
     m_colourScaleSet(false),
     m_colourMap(0),
     m_gain(1.0),
-    m_binScale(Colour3DPlotRenderer::LinearBinScale),
+    m_binScale(BinScale::Linear),
     m_normalization(ColumnOp::NoNormalization),
     m_invertVertical(false),
     m_opaque(false),
     m_smooth(false),
     m_peakResolution(256),

 
     } else if (name == "Bin Scale") {
 
 	*min = 0;
 	*max = 1;
-        *deflt = int(Colour3DPlotRenderer::LinearBinScale);
+        *deflt = int(BinScale::Linear);
 	val = (int)m_binScale;
 
     } else if (name == "Opaque") {
 	
         *deflt = 0;

     } else if (name == "Smooth") {
 	setSmooth(value ? true : false);
     } else if (name == "Bin Scale") {
 	switch (value) {
 	default:
-	case 0: setBinScale(Colour3DPlotRenderer::LinearBinScale); break;
-	case 1: setBinScale(Colour3DPlotRenderer::LogBinScale); break;
+	case 0: setBinScale(BinScale::Linear); break;
+	case 1: setBinScale(BinScale::Log); break;
 	}
     } else if (name == "Normalization") {
         switch (value) {
         default:
         case 0: setNormalization(ColumnOp::NoNormalization); break;

 {
     return m_gain;
 }
 
 void
-Colour3DPlotLayer::setBinScale(Colour3DPlotRenderer::BinScale binScale)
+Colour3DPlotLayer::setBinScale(BinScale binScale)
 {
     if (m_binScale == binScale) return;
     m_binScale = binScale;
     cacheInvalid();
     emit layerParametersChanged();
 }
 
-Colour3DPlotRenderer::BinScale
+BinScale
 Colour3DPlotLayer::getBinScale() const
 {
     return m_binScale;
 }
 

     double y = bin;
     if (!m_model) return y;
     double mn = 0, mx = m_model->getHeight();
     getDisplayExtents(mn, mx);
     double h = v->getPaintHeight();
-    if (m_binScale == Colour3DPlotRenderer::LinearBinScale) {
+    if (m_binScale == BinScale::Linear) {
         y = h - (((bin - mn) * h) / (mx - mn));
     } else {
         double logmin = mn + 1, logmax = mx + 1;
         LogRange::mapRange(logmin, logmax);
         y = h - (((LogRange::map(bin + 1) - logmin) * h) / (logmax - logmin));

     double bin = y;
     if (!m_model) return bin;
     double mn = 0, mx = m_model->getHeight();
     getDisplayExtents(mn, mx);
     double h = v->getPaintHeight();
-    if (m_binScale == Colour3DPlotRenderer::LinearBinScale) {
+    if (m_binScale == BinScale::Linear) {
         bin = mn + ((h - y) * (mx - mn)) / h;
     } else {
         double logmin = mn + 1, logmax = mx + 1;
         LogRange::mapRange(logmin, logmax);
         bin = LogRange::unmap(logmin + ((h - y) * (logmax - logmin)) / h) - 1;

         .arg(m_miny)
         .arg(m_maxy)
         .arg(m_invertVertical ? "true" : "false")
         .arg(m_opaque ? "true" : "false")
         .arg(QString("binScale=\"%1\" smooth=\"%2\" gain=\"%3\" ")
-             .arg((int)m_binScale)
+             .arg(int(m_binScale))
              .arg(m_smooth ? "true" : "false")
              .arg(m_gain));
     
     // New-style normalization attributes, allowing for more types of
     // normalization in future: write out the column normalization

     if (ok) setColourScale(colourScale);
 
     int colourMap = attributes.value("colourScheme").toInt(&ok);
     if (ok) setColourMap(colourMap);
 
-    Colour3DPlotRenderer::BinScale binScale = (Colour3DPlotRenderer::BinScale)
+    BinScale binScale = (BinScale)
 	attributes.value("binScale").toInt(&ok);
     if (ok) setBinScale(binScale);
 
     bool invertVertical =
         (attributes.value("invertVertical").trimmed() == "true");