comparison layer/Colour3DPlotLayer.cpp @ 1374:631897ba9fca zoom

Merge from default branch

 Colour3DPlotLayer::Colour3DPlotLayer() :
     m_model(0),
     m_colourScale(ColourScaleType::Linear),
     m_colourScaleSet(false),
     m_colourMap(0),
+    m_colourInverted(false),
     m_gain(1.0),
     m_binScale(BinScale::Linear),
     m_normalization(ColumnNormalization::None),
     m_normalizeVisibleArea(false),
     m_invertVertical(false),

 QString
 Colour3DPlotLayer::getPropertyGroupName(const PropertyName &name) const
 {
     if (name == "Normalization" ||
         name == "Colour Scale" ||
-        name == "Gain") return tr("Scale");
+        name == "Gain") {
+        return tr("Scale");
+    }
     if (name == "Bin Scale" ||
-        name == "Invert Vertical Scale") return tr("Bins");
+        name == "Invert Vertical Scale") {
+        return tr("Bins");
+    }
     if (name == "Opaque" ||
         name == "Smooth" ||
-        name == "Colour") return tr("Colour");
+        name == "Colour") {
+        return tr("Colour");
+    }
     return QString();
 }
 
 int
 Colour3DPlotLayer::getPropertyRangeAndValue(const PropertyName &name,

         *deflt = 0;
 
         val = convertFromColumnNorm(m_normalization, m_normalizeVisibleArea);
 
     } else if (name == "Invert Vertical Scale") {
-        
+
+        *min = 0;
+        *max = 1;
         *deflt = 0;
         val = (m_invertVertical ? 1 : 0);
 
     } else if (name == "Bin Scale") {
 

         *deflt = int(BinScale::Linear);
         val = (int)m_binScale;
 
     } else if (name == "Opaque") {
         
+        *min = 0;
+        *max = 1;
         *deflt = 0;
         val = (m_opaque ? 1 : 0);
         
     } else if (name == "Smooth") {
         
+        *min = 0;
+        *max = 1;
         *deflt = 0;
         val = (m_smooth ? 1 : 0);
         
     } else {
         val = Layer::getPropertyRangeAndValue(name, min, max, deflt);

 QString
 Colour3DPlotLayer::getPropertyValueLabel(const PropertyName &name,
                                     int value) const
 {
     if (name == "Colour") {
-        return ColourMapper::getColourMapName(value);
+        return ColourMapper::getColourMapLabel(value);
     }
     if (name == "Colour Scale") {
         switch (value) {
         default:
         case 0: return tr("Linear");

 
     if (sy < 0 || sy >= m_model->getHeight()) {
         return "";
     }
 
-    if (m_invertVertical) sy = m_model->getHeight() - sy - 1;
+    if (m_invertVertical) {
+        sy = m_model->getHeight() - sy - 1;
+    }
 
     float value = m_model->getValueAt(sx0, sy);
 
 //    cerr << "bin value (" << sx0 << "," << sy << ") is " << value << endl;
     

         }
 
         if (i > symin) {
 
             int idx = i - 1;
-            if (m_invertVertical) idx = m_model->getHeight() - idx - 1;
+            if (m_invertVertical) {
+                idx = m_model->getHeight() - idx - 1;
+            }
 
             QString text = m_model->getBinName(idx);
             if (text == "") text = QString("[%1]").arg(idx + 1);
 
             int ty = y0 + (h/2) - (paint.fontMetrics().height()/2) +

         sources.source = m_model;
         sources.peakCaches.push_back(getPeakCache());
 
         ColourScale::Parameters cparams;
         cparams.colourMap = m_colourMap;
+        cparams.inverted = m_colourInverted;
         cparams.scaleType = m_colourScale;
         cparams.gain = m_gain;
 
         double minValue = 0.0;
         double maxValue = 1.0;

             minValue = m_model->getMinimumLevel();
             maxValue = m_model->getMaximumLevel();
         }
 
         SVDEBUG << "Colour3DPlotLayer: rebuilding renderer, value range is "
-                << minValue << " -> " << maxValue << endl;
+                << minValue << " -> " << maxValue
+                << " (model min = " << m_model->getMinimumLevel()
+                << ", max = " << m_model->getMaximumLevel() << ")"
+                << endl;
         
         if (maxValue <= minValue) {
             maxValue = minValue + 0.1f;
         }
 

 void
 Colour3DPlotLayer::toXml(QTextStream &stream,
                          QString indent, QString extraAttributes) const
 {
     QString s = QString("scale=\"%1\" "
-                        "colourScheme=\"%2\" "
-                        "minY=\"%3\" "
-                        "maxY=\"%4\" "
-                        "invertVertical=\"%5\" "
-                        "opaque=\"%6\" %7")
+                        "minY=\"%2\" "
+                        "maxY=\"%3\" "
+                        "invertVertical=\"%4\" "
+                        "opaque=\"%5\" %6")
         .arg(convertFromColourScale(m_colourScale))
-        .arg(m_colourMap)
         .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(m_smooth ? "true" : "false")
              .arg(m_gain));
+
+    // New-style colour map attribute, by string id rather than by
+    // number
+
+    s += QString("colourMap=\"%1\" ")
+        .arg(ColourMapper::getColourMapId(m_colourMap));
+
+    // Old-style colour map attribute
+
+    s += QString("colourScheme=\"%1\" ")
+        .arg(ColourMapper::getBackwardCompatibilityColourMap(m_colourMap));
     
     // New-style normalization attributes, allowing for more types of
     // normalization in future: write out the column normalization
     // type separately, and then whether we are normalizing visible
     // area as well afterwards

 
     ColourScaleType colourScale = convertToColourScale
         (attributes.value("scale").toInt(&ok));
     if (ok) setColourScale(colourScale);
 
-    int colourMap = attributes.value("colourScheme").toInt(&ok);
-    if (ok) setColourMap(colourMap);
+    QString colourMapId = attributes.value("colourMap");
+    int colourMap = ColourMapper::getColourMapById(colourMapId);
+    if (colourMap >= 0) {
+        setColourMap(colourMap);
+    } else {
+        colourMap = attributes.value("colourScheme").toInt(&ok);
+        if (ok && colourMap < ColourMapper::getColourMapCount()) {
+            setColourMap(colourMap);
+        }
+    }
 
     BinScale binScale = (BinScale)
         attributes.value("binScale").toInt(&ok);
     if (ok) setBinScale(binScale);