comparison layer/SpectrogramLayer.cpp @ 197:6b023411087b

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

     m_colourRotation(0),
     m_minFrequency(10),
     m_maxFrequency(8000),
     m_initialMaxFrequency(8000),
     m_colourScale(dBColourScale),
-    m_colourScheme(0),
+    m_colourMap(0),
     m_frequencyScale(LinearFrequencyScale),
     m_binDisplay(AllBins),
     m_normalizeColumns(false),
     m_normalizeVisibleArea(false),
     m_lastEmittedZoomStep(-1),

     Preferences *prefs = Preferences::getInstance();
     connect(prefs, SIGNAL(propertyChanged(PropertyContainer::PropertyName)),
             this, SLOT(preferenceChanged(PropertyContainer::PropertyName)));
     setWindowType(prefs->getWindowType());
 
-    setColourmap();
+    initialisePalette();
 }
 
 SpectrogramLayer::~SpectrogramLayer()
 {
     delete m_updateTimer;

         name == "Frequency Scale") return tr("Bins");
     if (name == "Window Size" ||
 	name == "Window Increment" ||
         name == "Zero Padding") return tr("Window");
     if (name == "Colour" ||
-//	name == "Gain" ||
 	name == "Threshold" ||
 	name == "Colour Rotation") return tr("Colour");
     if (name == "Normalize Columns" ||
         name == "Normalize Visible Area" ||
-//	name == "Bin Display" ||
         name == "Gain" ||
 	name == "Colour Scale") return tr("Scale");
-//    if (name == "Max Frequency" ||
-//	name == "Min Frequency" ||
-//	name == "Frequency Scale" ||
-//	name == "Frequency Adjustment") return tr("Range");
     return QString();
 }
 
 int
 SpectrogramLayer::getPropertyRangeAndValue(const PropertyName &name,

     } else if (name == "Colour") {
 
 	*min = 0;
 	*max = ColourMapper::getColourMapCount() - 1;
 
-	deft = m_colourScheme;
+	deft = m_colourMap;
 
     } else if (name == "Window Size") {
 
 	*min = 0;
 	*max = 10;

 	if (value == -50) setThreshold(0.0);
 	else setThreshold(AudioLevel::dB_to_multiplier(value));
     } else if (name == "Colour Rotation") {
 	setColourRotation(value);
     } else if (name == "Colour") {
-        setColourScheme(value);
+        setColourMap(value);
     } else if (name == "Window Size") {
 	setWindowSize(32 << value);
     } else if (name == "Window Increment") {
         setWindowHopLevel(value);
     } else if (name == "Zero Padding") {

     if (r < 0) r = 0;
     if (r > 256) r = 256;
     int distance = r - m_colourRotation;
 
     if (distance != 0) {
-	rotateColourmap(-distance);
+	rotatePalette(-distance);
 	m_colourRotation = r;
     }
     
     emit layerParametersChanged();
 }

 {
     return m_colourScale;
 }
 
 void
-SpectrogramLayer::setColourScheme(int scheme)
-{
-    if (m_colourScheme == scheme) return;
+SpectrogramLayer::setColourMap(int map)
+{
+    if (m_colourMap == map) return;
 
     invalidatePixmapCaches();
     
-    m_colourScheme = scheme;
-    setColourmap();
+    m_colourMap = map;
+    initialisePalette();
 
     emit layerParametersChanged();
 }
 
 int
-SpectrogramLayer::getColourScheme() const
-{
-    return m_colourScheme;
+SpectrogramLayer::getColourMap() const
+{
+    return m_colourMap;
 }
 
 void
 SpectrogramLayer::setFrequencyScale(FrequencyScale frequencyScale)
 {

         m_updateTimer = 0;
     }
 }
 
 void
-SpectrogramLayer::setColourmap()
+SpectrogramLayer::initialisePalette()
 {
     int formerRotation = m_colourRotation;
 
-    if (m_colourScheme == (int)ColourMapper::BlackOnWhite) {
-	m_colourMap.setColour(NO_VALUE, Qt::white);
+    if (m_colourMap == (int)ColourMapper::BlackOnWhite) {
+	m_palette.setColour(NO_VALUE, Qt::white);
     } else {
-	m_colourMap.setColour(NO_VALUE, Qt::black);
-    }
-
-    ColourMapper mapper(m_colourScheme, 1.f, 256.f);
+	m_palette.setColour(NO_VALUE, Qt::black);
+    }
+
+    ColourMapper mapper(m_colourMap, 1.f, 255.f);
     
     for (int pixel = 1; pixel < 256; ++pixel) {
-
-        m_colourMap.setColour(pixel, mapper.map(pixel));
+        m_palette.setColour(pixel, mapper.map(pixel));
     }
 
     m_crosshairColour = mapper.getContrastingColour();
 
     m_colourRotation = 0;
-    rotateColourmap(m_colourRotation - formerRotation);
+    rotatePalette(m_colourRotation - formerRotation);
     m_colourRotation = formerRotation;
 }
 
 void
-SpectrogramLayer::rotateColourmap(int distance)
+SpectrogramLayer::rotatePalette(int distance)
 {
     QColor newPixels[256];
 
-    newPixels[NO_VALUE] = m_colourMap.getColour(NO_VALUE);
+    newPixels[NO_VALUE] = m_palette.getColour(NO_VALUE);
 
     for (int pixel = 1; pixel < 256; ++pixel) {
 	int target = pixel + distance;
 	while (target < 1) target += 255;
 	while (target > 255) target -= 255;
-	newPixels[target] = m_colourMap.getColour(pixel);
+	newPixels[target] = m_palette.getColour(pixel);
     }
 
     for (int pixel = 0; pixel < 256; ++pixel) {
-	m_colourMap.setColour(pixel, newPixels[pixel]);
+	m_palette.setColour(pixel, newPixels[pixel]);
     }
 }
 
 float
 SpectrogramLayer::calculateFrequency(size_t bin,

 }
 
 void
 SpectrogramLayer::paint(View *v, QPainter &paint, QRect rect) const
 {
-    if (m_colourScheme == (int)ColourMapper::BlackOnWhite) {
+    if (m_colourMap == (int)ColourMapper::BlackOnWhite) {
 	v->setLightBackground(true);
     } else {
 	v->setLightBackground(false);
     }
 

 
     if (m_drawBuffer.width() < w || m_drawBuffer.height() < h) {
         m_drawBuffer = QImage(w, h, QImage::Format_RGB32);
     }
 
-    m_drawBuffer.fill(m_colourMap.getColour(0).rgb());
+    m_drawBuffer.fill(m_palette.getColour(0).rgb());
 
     int sr = m_model->getSampleRate();
 
     // Set minFreq and maxFreq to the frequency extents of the possibly
     // zero-padded visible bin range, and displayMinFreq and displayMaxFreq

 
 		float avg = ymag[y] / ydiv[y];
 		pixel = getDisplayValue(v, avg);
 
 		assert(x <= m_drawBuffer.width());
-		QColor c = m_colourMap.getColour(pixel);
+		QColor c = m_palette.getColour(pixel);
 		m_drawBuffer.setPixel(x, y,
                                       qRgb(c.red(), c.green(), c.blue()));
 	    }
 	}
     }

             int colour = getDisplayValue(v, value * m_gain);
 */
 /*
 	    int colour = (i * 255) / ch + 1;
 */
-	    paint.setPen(m_colourMap.getColour(colour));
+	    paint.setPen(m_palette.getColour(colour));
 
             int y = textHeight * topLines + 4 + ch - i;
 
             paint.drawLine(5 + cw - cbw, y, cw + 2, y);
 

 		 "normalizeColumns=\"%8\" "
                  "normalizeVisibleArea=\"%9\"")
 	.arg(m_minFrequency)
 	.arg(m_maxFrequency)
 	.arg(m_colourScale)
-	.arg(m_colourScheme)
+	.arg(m_colourMap)
 	.arg(m_colourRotation)
 	.arg(m_frequencyScale)
 	.arg(m_binDisplay)
 	.arg(m_normalizeColumns ? "true" : "false")
         .arg(m_normalizeVisibleArea ? "true" : "false");

 
     ColourScale colourScale = (ColourScale)
 	attributes.value("colourScale").toInt(&ok);
     if (ok) setColourScale(colourScale);
 
-    int colourScheme = attributes.value("colourScheme").toInt(&ok);
-    if (ok) setColourScheme(colourScheme);
+    int colourMap = attributes.value("colourScheme").toInt(&ok);
+    if (ok) setColourMap(colourMap);
 
     int colourRotation = attributes.value("colourRotation").toInt(&ok);
     if (ok) setColourRotation(colourRotation);
 
     FrequencyScale frequencyScale = (FrequencyScale)