comparison layer/SliceLayer.cpp @ 197:6b023411087b

* Work on harmonising colour and scale ranges between types of layer
* Add normalize options to colour 3d plot layer

 #include "view/View.h"
 #include "base/AudioLevel.h"
 #include "base/RangeMapper.h"
 #include "base/RealTime.h"
 
+#include "ColourMapper.h"
 #include "PaintAssistant.h"
 
 #include <QPainter>
 #include <QPainterPath>
 
 SliceLayer::SliceLayer() :
     m_sliceableModel(0),
     m_colour(Qt::darkBlue),
+    m_colourMap(0),
     m_energyScale(dBScale),
     m_samplingMode(SamplePeak),
     m_plotStyle(PlotSteps),
     m_binScale(LinearBins),
     m_normalize(false),

     }
 
     float py = 0;
     float nx = xorigin;
 
+    ColourMapper mapper(m_colourMap, 0, 1);
+
     for (size_t bin = 0; bin < mh; ++bin) {
 
         float x;
 
         switch (m_binScale) {

         }
 
         float value = values[bin];
 
         value *= m_gain;
+        float norm = 0.f;
         float y = 0.f;
  
         switch (m_energyScale) {
 
         case dBScale:
         {
             float db = thresh;
             if (value > 0.f) db = 10.f * log10f(value);
             if (db < thresh) db = thresh;
-            float val = (db - thresh) / -thresh;
-            y = yorigin - (float(h) * val);
+            norm = (db - thresh) / -thresh;
+            y = yorigin - (float(h) * norm);
             break;
         }
 
         case MeterScale:
-            y = yorigin - AudioLevel::multiplier_to_preview(value, h);
+            y = AudioLevel::multiplier_to_preview(value, h);
+            norm = float(y) / float(h);
+            y = yorigin - y;
             break;
 
         default:
+            norm = value;
             y = yorigin - (float(h) * value);
             break;
         }
 
         if (m_plotStyle == PlotLines) {

             path.moveTo(x, yorigin);
             path.lineTo(x, y);
             path.lineTo(nx, y);
             path.lineTo(nx, yorigin);
             path.lineTo(x, yorigin);
+
+        } else if (m_plotStyle == PlotFilledBlocks) {
+
+            paint.fillRect(QRectF(x, y, nx - x, yorigin - y), mapper.map(norm));
         }
 
         py = y;
     }
 
-    paint.drawPath(path);
+    if (m_plotStyle != PlotFilledBlocks) {
+        paint.drawPath(path);
+    }
     paint.restore();
 
-    if (v->getViewManager() && v->getViewManager()->shouldShowFrameCount()) {
+    QPoint discard;
+
+    if (v->getViewManager() && v->getViewManager()->shouldShowFrameCount() &&
+        v->shouldIlluminateLocalFeatures(this, discard)) {
 
         int sampleRate = m_sliceableModel->getSampleRate();
 
         QString startText = QString("%1 / %2")
             .arg(QString::fromStdString

 	
 	deft = (m_normalize ? 1 : 0);
 
     } else if (name == "Colour") {
 
-	*min = 0;
-	*max = 5;
-
-	if (m_colour == Qt::black) deft = 0;
-	else if (m_colour == Qt::darkRed) deft = 1;
-	else if (m_colour == Qt::darkBlue) deft = 2;
-	else if (m_colour == Qt::darkGreen) deft = 3;
-	else if (m_colour == QColor(200, 50, 255)) deft = 4;
-	else if (m_colour == QColor(255, 150, 50)) deft = 5;
+        if (m_plotStyle == PlotFilledBlocks) {
+            
+            *min = 0;
+            *max = ColourMapper::getColourMapCount() - 1;
+
+            deft = m_colourMap;
+
+        } else {
+
+            *min = 0;
+            *max = 5;
+
+            if (m_colour == Qt::black) deft = 0;
+            else if (m_colour == Qt::darkRed) deft = 1;
+            else if (m_colour == Qt::darkBlue) deft = 2;
+            else if (m_colour == Qt::darkGreen) deft = 3;
+            else if (m_colour == QColor(200, 50, 255)) deft = 4;
+            else if (m_colour == QColor(255, 150, 50)) deft = 5;
+        }
 
     } else if (name == "Scale") {
 
 	*min = 0;
 	*max = 2;

 	deft = (int)m_samplingMode;
 
     } else if (name == "Plot Type") {
         
         *min = 0;
-        *max = 2;
+        *max = 3;
 
         deft = (int)m_plotStyle;
 
     } else if (name == "Bin Scale") {
         
         *min = 0;
-        *max = 2;
+//        *max = 2;
+        *max = 1; // I don't think we really do want to offer inverted log
 
         deft = (int)m_binScale;
 
     } else {
 	deft = Layer::getPropertyRangeAndValue(name, min, max);

 QString
 SliceLayer::getPropertyValueLabel(const PropertyName &name,
 				    int value) const
 {
     if (name == "Colour") {
-	switch (value) {
-	default:
-	case 0: return tr("Black");
-	case 1: return tr("Red");
-	case 2: return tr("Blue");
-	case 3: return tr("Green");
-	case 4: return tr("Purple");
-	case 5: return tr("Orange");
+        if (m_plotStyle == PlotFilledBlocks) {
+            return ColourMapper::getColourMapName(value);
+        } else {
+            switch (value) {
+            default:
+            case 0: return tr("Black");
+            case 1: return tr("Red");
+            case 2: return tr("Blue");
+            case 3: return tr("Green");
+            case 4: return tr("Purple");
+            case 5: return tr("Orange");
+            }
 	}
     }
     if (name == "Scale") {
 	switch (value) {
 	default:

 	switch (value) {
 	default:
 	case 0: return tr("Lines");
 	case 1: return tr("Steps");
 	case 2: return tr("Blocks");
+	case 3: return tr("Colours");
 	}
     }
     if (name == "Bin Scale") {
 	switch (value) {
 	default:

 SliceLayer::setProperty(const PropertyName &name, int value)
 {
     if (name == "Gain") {
 	setGain(pow(10, float(value)/20.0));
     } else if (name == "Colour") {
-	switch (value) {
-	default:
-	case 0:	setBaseColour(Qt::black); break;
-	case 1: setBaseColour(Qt::darkRed); break;
-	case 2: setBaseColour(Qt::darkBlue); break;
-	case 3: setBaseColour(Qt::darkGreen); break;
-	case 4: setBaseColour(QColor(200, 50, 255)); break;
-	case 5: setBaseColour(QColor(255, 150, 50)); break;
+        if (m_plotStyle == PlotFilledBlocks) {
+            setFillColourMap(value);
+        } else {
+            switch (value) {
+            default:
+            case 0: setBaseColour(Qt::black); break;
+            case 1: setBaseColour(Qt::darkRed); break;
+            case 2: setBaseColour(Qt::darkBlue); break;
+            case 3: setBaseColour(Qt::darkGreen); break;
+            case 4: setBaseColour(QColor(200, 50, 255)); break;
+            case 5: setBaseColour(QColor(255, 150, 50)); break;
+            }
 	}
     } else if (name == "Scale") {
 	switch (value) {
 	default:
 	case 0: setEnergyScale(LinearScale); break;

     m_colour = colour;
     emit layerParametersChanged();
 }
 
 void
+SliceLayer::setFillColourMap(int map)
+{
+    if (m_colourMap == map) return;
+    m_colourMap = map;
+    emit layerParametersChanged();
+}
+
+void
 SliceLayer::setEnergyScale(EnergyScale scale)
 {
     if (m_energyScale == scale) return;
     m_energyScale = scale;
     emit layerParametersChanged();

 
 void
 SliceLayer::setPlotStyle(PlotStyle style)
 {
     if (m_plotStyle == style) return;
+    bool colourTypeChanged = (style == PlotFilledBlocks ||
+                              m_plotStyle == PlotFilledBlocks);
     m_plotStyle = style;
+    if (colourTypeChanged) {
+        emit layerParameterRangesChanged();
+    }
     emit layerParametersChanged();
 }
 
 void
 SliceLayer::setBinScale(BinScale scale)

 SliceLayer::toXmlString(QString indent, QString extraAttributes) const
 {
     QString s;
     
     s += QString("colour=\"%1\" "
-		 "energyScale=\"%2\" "
-                 "samplingMode=\"%3\" "
-                 "gain=\"%4\" "
-                 "normalize=\"%5\"")
+                 "colourScheme=\"%2\" "
+		 "energyScale=\"%3\" "
+                 "samplingMode=\"%4\" "
+                 "gain=\"%5\" "
+                 "normalize=\"%6\"")
 	.arg(encodeColour(m_colour))
+        .arg(m_colourMap)
 	.arg(m_energyScale)
         .arg(m_samplingMode)
         .arg(m_gain)
         .arg(m_normalize ? "true" : "false");
 

 
     SamplingMode mode = (SamplingMode)
 	attributes.value("samplingMode").toInt(&ok);
     if (ok) setSamplingMode(mode);
 
+    int colourMap = attributes.value("colourScheme").toInt(&ok);
+    if (ok) setFillColourMap(colourMap);
+
     float gain = attributes.value("gain").toFloat(&ok);
     if (ok) setGain(gain);
 
     bool normalize = (attributes.value("normalize").trimmed() == "true");
     setNormalize(normalize);