comparison layer/Colour3DPlotLayer.cpp @ 465:b77b79413cdb

* fix some warnings, remove debug

     m_colourScaleSet(false),
     m_colourMap(0),
     m_normalizeColumns(false),
     m_normalizeVisibleArea(false),
     m_invertVertical(false),
+    m_opaque(false),
     m_miny(0),
     m_maxy(0)
 {
     
 }

     list.push_back("Colour");
     list.push_back("Colour Scale");
     list.push_back("Normalize Columns");
     list.push_back("Normalize Visible Area");
     list.push_back("Invert Vertical Scale");
+    list.push_back("Opaque");
     return list;
 }
 
 QString
 Colour3DPlotLayer::getPropertyLabel(const PropertyName &name) const

     if (name == "Colour") return tr("Colour");
     if (name == "Colour Scale") return tr("Scale");
     if (name == "Normalize Columns") return tr("Normalize Columns");
     if (name == "Normalize Visible Area") return tr("Normalize Visible Area");
     if (name == "Invert Vertical Scale") return tr("Invert Vertical Scale");
+    if (name == "Opaque") return tr("Always Opaque");
     return "";
 }
 
 QString
 Colour3DPlotLayer::getPropertyIconName(const PropertyName &name) const
 {
     if (name == "Normalize Columns") return "normalise-columns";
     if (name == "Normalize Visible Area") return "normalise";
     if (name == "Invert Vertical Scale") return "invert-vertical";
+    if (name == "Opaque") return "opaque";
     return "";
 }
 
 Layer::PropertyType
 Colour3DPlotLayer::getPropertyType(const PropertyName &name) const
 {
     if (name == "Normalize Columns") return ToggleProperty;
     if (name == "Normalize Visible Area") return ToggleProperty;
     if (name == "Invert Vertical Scale") return ToggleProperty;
+    if (name == "Opaque") return ToggleProperty;
     return ValueProperty;
 }
 
 QString
 Colour3DPlotLayer::getPropertyGroupName(const PropertyName &name) const
 {
     if (name == "Normalize Columns" ||
         name == "Normalize Visible Area" ||
         name == "Invert Vertical Scale" ||
 	name == "Colour Scale") return tr("Scale");
+    if (name == "Opaque" ||
+        name == "Colour") return tr("Colour");
     return QString();
 }
 
 int
 Colour3DPlotLayer::getPropertyRangeAndValue(const PropertyName &name,

     } else if (name == "Invert Vertical Scale") {
 	
         *deflt = 0;
 	val = (m_invertVertical ? 1 : 0);
 
+    } else if (name == "Opaque") {
+	
+        *deflt = 0;
+	val = (m_opaque ? 1 : 0);
+        
     } else {
 	val = Layer::getPropertyRangeAndValue(name, min, max, deflt);
     }
 
     return val;

 	setNormalizeColumns(value ? true : false);
     } else if (name == "Normalize Visible Area") {
 	setNormalizeVisibleArea(value ? true : false);
     } else if (name == "Invert Vertical Scale") {
 	setInvertVertical(value ? true : false);
+    } else if (name == "Opaque") {
+	setOpaque(value ? true : false);
     }
 }
 
 void
 Colour3DPlotLayer::setColourScale(ColourScale scale)

     m_invertVertical = n;
     cacheInvalid();
     emit layerParametersChanged();
 }
 
+void
+Colour3DPlotLayer::setOpaque(bool n)
+{
+    if (m_opaque == n) return;
+    m_opaque = n;
+    emit layerParametersChanged();
+}
+
 bool
 Colour3DPlotLayer::getInvertVertical() const
 {
     return m_invertVertical;
+}
+
+bool
+Colour3DPlotLayer::getOpaque() const
+{
+    return m_opaque;
 }
 
 bool
 Colour3DPlotLayer::isLayerScrollable(const View *v) const
 {

             mmin = -1.f;
             mmax = 1.f;
         }
     
         if (max == min) max = min + 1.0;
+        if (mmax == mmin) mmax = mmin + 1.0;
     
         paint.setPen(v->getForeground());
         paint.drawRect(4, 10, cw - 8, ch+1);
 
         for (int y = 0; y < ch; ++y) {
             float value = ((max - min) * (ch - y - 1)) / ch + min;
             if (m_colourScale == LogScale) {
                 value = LogRange::map(value);
             }
             int pixel = int(((value - mmin) * 256) / (mmax - mmin));
-            QRgb c = m_cache->color(pixel);
-//            QRgb c = m_cache->color(((ch - y) * 255) / ch);
-            paint.setPen(QColor(qRed(c), qGreen(c), qBlue(c)));
-            paint.drawLine(5, 11 + y, cw - 5, 11 + y);
+            if (pixel >= 0 && pixel < 256) {
+                QRgb c = m_cache->color(pixel);
+                paint.setPen(QColor(qRed(c), qGreen(c), qBlue(c)));
+                paint.drawLine(5, 11 + y, cw - 5, 11 + y);
+            } else {
+                std::cerr << "WARNING: Colour3DPlotLayer::paintVerticalScale: value " << value << ", mmin " << mmin << ", mmax " << mmax << " leads to invalid pixel " << pixel << std::endl;
+            }
         }
 
         QString minstr = QString("%1").arg(min);
         QString maxstr = QString("%1").arg(max);
         

 
 #ifdef DEBUG_COLOUR_3D_PLOT_LAYER_PAINT
     std::cerr << "Colour3DPlotLayer::paint: height = "<< m_model->getHeight() << ", modelStart = " << modelStart << ", resolution = " << modelResolution << ", model rate = " << m_model->getSampleRate() << std::endl;
 #endif
 
-    if (int(m_model->getHeight()) >= v->height() ||
+    if (m_opaque || 
+        int(m_model->getHeight()) >= v->height() ||
         int(modelResolution * m_model->getSampleRate()) < v->getZoomLevel() / 2) {
 #ifdef DEBUG_COLOUR_3D_PLOT_LAYER_PAINT
         std::cerr << "calling paintDense" << std::endl;
 #endif
         paintDense(v, paint, rect);

     QString s = QString("scale=\"%1\" "
                         "colourScheme=\"%2\" "
                         "normalizeColumns=\"%3\" "
                         "normalizeVisibleArea=\"%4\" "
                         "minY=\"%5\" "
-                        "maxY=\"%6\" ")
+                        "maxY=\"%6\" "
+                        "invertVertical=\"%7\" "
+                        "opaque=\"%8\"")
 	.arg((int)m_colourScale)
         .arg(m_colourMap)
         .arg(m_normalizeColumns ? "true" : "false")
         .arg(m_normalizeVisibleArea ? "true" : "false")
         .arg(m_miny)
-        .arg(m_maxy);
+        .arg(m_maxy)
+        .arg(m_invertVertical ? "true" : "false")
+        .arg(m_opaque ? "true" : "false");
 
     Layer::toXml(stream, indent, extraAttributes + " " + s);
 }
 
 void

 
     bool normalizeVisibleArea =
         (attributes.value("normalizeVisibleArea").trimmed() == "true");
     setNormalizeVisibleArea(normalizeVisibleArea);
 
+    bool invertVertical =
+        (attributes.value("invertVertical").trimmed() == "true");
+    setInvertVertical(invertVertical);
+
+    bool opaque =
+        (attributes.value("opaque").trimmed() == "true");
+    setNormalizeVisibleArea(opaque);
+
     float min = attributes.value("minY").toFloat(&ok);
     float max = attributes.value("maxY").toFloat(&alsoOk);
     if (ok && alsoOk) setDisplayExtents(min, max);
 }