comparison layer/SpectrogramLayer.cpp @ 97:a0e7edf9703a

* Use fractional window overlaps in the spectrogram, instead of percentages
  (90% is kind of meaningless when none of your window sizes are divisible
  by 10!)
* ResizeableBitmap -> ResizeableBitset and the odd other tidy up

 #include <iostream>
 
 #include <cassert>
 #include <cmath>
 
-//#define DEBUG_SPECTROGRAM_REPAINT 1
+#define DEBUG_SPECTROGRAM_REPAINT 1
 
 static double mod(double x, double y)
 {
     double a = floor(x / y);
     double b = x - (y * a);

     Layer(),
     m_model(0),
     m_channel(0),
     m_windowSize(1024),
     m_windowType(HanningWindow),
-    m_windowOverlap(50),
+    m_windowHopLevel(2),
     m_gain(1.0),
     m_threshold(0.0),
     m_colourRotation(0),
     m_minFrequency(0),
     m_maxFrequency(8000),

     m_lastFillExtent(0),
     m_exiting(false)
 {
     if (config == MelodicRange) {
 	setWindowSize(8192);
-	setWindowOverlap(90);
+	setWindowHopLevel(4);
 	setWindowType(ParzenWindow);
 	setMaxFrequency(1000);
 	setColourScale(LinearColourScale);
     } else if (config == MelodicPeaks) {
 	setWindowSize(4096);
-	setWindowOverlap(90);
+	setWindowHopLevel(5);
 	setWindowType(BlackmanWindow);
 	setMaxFrequency(2000);
 	setMinFrequency(40);
 	setFrequencyScale(LogFrequencyScale);
 	setColourScale(MeterColourScale);

     PropertyList list;
     list.push_back("Colour");
     list.push_back("Colour Scale");
     list.push_back("Window Type");
     list.push_back("Window Size");
-    list.push_back("Window Overlap");
+    list.push_back("Window Increment");
     list.push_back("Normalize Columns");
     list.push_back("Bin Display");
     list.push_back("Threshold");
     list.push_back("Gain");
     list.push_back("Colour Rotation");

 {
     if (name == "Colour") return tr("Colour");
     if (name == "Colour Scale") return tr("Colour Scale");
     if (name == "Window Type") return tr("Window Type");
     if (name == "Window Size") return tr("Window Size");
-    if (name == "Window Overlap") return tr("Window Overlap");
+    if (name == "Window Increment") return tr("Window Increment");
     if (name == "Normalize Columns") return tr("Normalize Columns");
     if (name == "Bin Display") return tr("Bin Display");
     if (name == "Threshold") return tr("Threshold");
     if (name == "Gain") return tr("Gain");
     if (name == "Colour Rotation") return tr("Colour Rotation");

 QString
 SpectrogramLayer::getPropertyGroupName(const PropertyName &name) const
 {
     if (name == "Window Size" ||
 	name == "Window Type" ||
-	name == "Window Overlap") return tr("Window");
+	name == "Window Increment") return tr("Window");
     if (name == "Colour" ||
 	name == "Gain" ||
 	name == "Threshold" ||
 	name == "Colour Rotation") return tr("Colour");
     if (name == "Normalize Columns" ||

 	
 	deft = 0;
 	int ws = m_windowSize;
 	while (ws > 32) { ws >>= 1; deft ++; }
 
-    } else if (name == "Window Overlap") {
+    } else if (name == "Window Increment") {
 	
 	*min = 0;
-	*max = 4;
+	*max = 5;
 	
-	deft = m_windowOverlap / 25;
-	if (m_windowOverlap == 90) deft = 4;
+        deft = m_windowHopLevel;
     
     } else if (name == "Min Frequency") {
 
 	*min = 0;
 	*max = 9;

 	}
     }
     if (name == "Window Size") {
 	return QString("%1").arg(32 << value);
     }
-    if (name == "Window Overlap") {
+    if (name == "Window Increment") {
 	switch (value) {
 	default:
-	case 0: return tr("0%");
-	case 1: return tr("25%");
-	case 2: return tr("50%");
-	case 3: return tr("75%");
-	case 4: return tr("90%");
+	case 0: return tr("1/1");
+	case 1: return tr("3/4");
+	case 2: return tr("1/2");
+	case 3: return tr("1/4");
+	case 4: return tr("1/8");
+	case 5: return tr("1/16");
 	}
     }
     if (name == "Min Frequency") {
 	switch (value) {
 	default:

 	}
     } else if (name == "Window Type") {
 	setWindowType(WindowType(value));
     } else if (name == "Window Size") {
 	setWindowSize(32 << value);
-    } else if (name == "Window Overlap") {
-	if (value == 4) setWindowOverlap(90);
-	else setWindowOverlap(25 * value);
+    } else if (name == "Window Increment") {
+        setWindowHopLevel(value);
     } else if (name == "Min Frequency") {
 	switch (value) {
 	default:
 	case 0: setMinFrequency(0); break;
 	case 1: setMinFrequency(10); break;

 {
     return m_windowSize;
 }
 
 void
-SpectrogramLayer::setWindowOverlap(size_t wi)
-{
-    if (m_windowOverlap == wi) return;
+SpectrogramLayer::setWindowHopLevel(size_t v)
+{
+    if (m_windowHopLevel == v) return;
 
     m_mutex.lock();
     m_cacheInvalid = true;
     invalidatePixmapCaches();
     
-    m_windowOverlap = wi;
+    m_windowHopLevel = v;
     
     m_mutex.unlock();
 
     emit layerParametersChanged();
 
     fillCache();
 }
 
 size_t
-SpectrogramLayer::getWindowOverlap() const
-{
-    return m_windowOverlap;
+SpectrogramLayer::getWindowHopLevel() const
+{
+    return m_windowHopLevel;
 }
 
 void
 SpectrogramLayer::setWindowType(WindowType w)
 {

     
     fftw_execute(plan);
 
     double factor = 0.0;
 
-    // Calculate magnitude and phase from real and imaginary in
-    // output[i][0] and output[i][1] respectively, and store the phase
-    // straight into cache and the magnitude back into output[i][0]
-    // (because we'll need to know the normalization factor,
-    // i.e. maximum magnitude in this column, before we can store it)
-
     for (size_t i = 0; i < windowSize/2; ++i) {
 
 	double mag = sqrt(output[i][0] * output[i][0] +
 			  output[i][1] * output[i][1]);
 	mag /= windowSize / 2;

 
 	    WindowType windowType = m_layer.m_windowType;
 	    size_t windowSize = m_layer.m_windowSize;
 	    size_t windowIncrement = m_layer.getWindowIncrement();
 
+            std::cerr << "\nWINDOW INCREMENT: " << windowIncrement << " (for hop level " << m_layer.m_windowHopLevel << ")\n" << std::endl;
+
 	    size_t visibleStart = m_layer.m_candidateFillStartFrame;
 	    visibleStart = (visibleStart / windowIncrement) * windowIncrement;
 
 	    size_t width = (end - start) / windowIncrement + 1;
 	    size_t height = windowSize / 2;

 
 	    for (int q = q0i; q <= q1i; ++q) {
 		for (int s = s0i; s <= s1i; ++s) {
 		    if (s >= 0 && q >= 0 && s < cw && q < ch) {
 
-                        if (!m_cache->haveColumnAt(s)) continue;
+                        if (!m_cache->haveSetColumnAt(s)) continue;
 
 			float value;
 
 			value = m_cache->getPhaseAt(s, q);
 			if (!have || value < phaseMin) { phaseMin = value; }

 
     if (m_drawBuffer.width() < w || m_drawBuffer.height() < h) {
         m_drawBuffer = QImage(w, h, QImage::Format_RGB32);
     }
 
-//    if (m_binDisplay == PeakFrequencies) {
-        m_drawBuffer.fill(m_colourMap.getColour(0).rgb());
-//    }
+    m_drawBuffer.fill(m_colourMap.getColour(0).rgb());
 
     int sr = m_model->getSampleRate();
     
     size_t bins = m_windowSize / 2;
     if (m_maxFrequency > 0) {

 	    }
 	}
 
         for (int s = s0i; s <= s1i; ++s) {
 
-            if (!m_cache->haveColumnAt(s)) continue;
+            if (!m_cache->haveSetColumnAt(s)) continue;
 
             for (size_t q = minbin; q < bins; ++q) {
 
                 float y0 = yval[q + 1];
                 float y1 = yval[q];

     QString s;
     
     s += QString("channel=\"%1\" "
 		 "windowSize=\"%2\" "
 		 "windowType=\"%3\" "
-		 "windowOverlap=\"%4\" "
+		 "windowHopLevel=\"%4\" "
 		 "gain=\"%5\" "
 		 "threshold=\"%6\" ")
 	.arg(m_channel)
 	.arg(m_windowSize)
 	.arg(m_windowType)
-	.arg(m_windowOverlap)
+	.arg(m_windowHopLevel)
 	.arg(m_gain)
 	.arg(m_threshold);
 
     s += QString("minFrequency=\"%1\" "
 		 "maxFrequency=\"%2\" "

 
     WindowType windowType = (WindowType)
 	attributes.value("windowType").toInt(&ok);
     if (ok) setWindowType(windowType);
 
-    size_t windowOverlap = attributes.value("windowOverlap").toUInt(&ok);
-    if (ok) setWindowOverlap(windowOverlap);
+    size_t windowHopLevel = attributes.value("windowHopLevel").toUInt(&ok);
+    if (ok) setWindowHopLevel(windowHopLevel);
+    else {
+        size_t windowOverlap = attributes.value("windowOverlap").toUInt(&ok);
+        // a percentage value
+        if (ok) {
+            if (windowOverlap == 0) setWindowHopLevel(0);
+            else if (windowOverlap == 25) setWindowHopLevel(1);
+            else if (windowOverlap == 50) setWindowHopLevel(2);
+            else if (windowOverlap == 75) setWindowHopLevel(3);
+            else if (windowOverlap == 90) setWindowHopLevel(4);
+        }
+    }
 
     float gain = attributes.value("gain").toFloat(&ok);
     if (ok) setGain(gain);
 
     float threshold = attributes.value("threshold").toFloat(&ok);