comparison layer/SpectrogramLayer.cpp @ 1093:cd22f74dc159 spectrogram-minor-refactor

Use enums from origin classes

     m_minFrequency(10),
     m_maxFrequency(8000),
     m_initialMaxFrequency(8000),
     m_colourScale(ColourScale::LogColourScale),
     m_colourMap(0),
-    m_frequencyScale(LinearFrequencyScale),
-    m_binDisplay(AllBins),
+    m_binScale(Colour3DPlotRenderer::LinearBinScale),
+    m_binDisplay(Colour3DPlotRenderer::AllBins),
     m_normalization(ColumnOp::NoNormalization),
     m_lastEmittedZoomStep(-1),
     m_synchronous(false),
     m_haveDetailedScale(false),
     m_exiting(false),

         m_initialMaxFrequency = 1500;
 	setMaxFrequency(1500);
         setMinFrequency(40);
 	setColourScale(ColourScale::LinearColourScale);
         setColourMap(ColourMapper::Sunset);
-        setFrequencyScale(LogFrequencyScale);
+        setBinScale(Colour3DPlotRenderer::LogBinScale);
         colourConfigName = "spectrogram-melodic-colour";
         colourConfigDefault = int(ColourMapper::Sunset);
 //        setGain(20);
     } else if (config == MelodicPeaks) {
 	setWindowSize(4096);
 	setWindowHopLevel(5);
         m_initialMaxFrequency = 2000;
 	setMaxFrequency(2000);
 	setMinFrequency(40);
-	setFrequencyScale(LogFrequencyScale);
+	setBinScale(Colour3DPlotRenderer::LogBinScale);
 	setColourScale(ColourScale::LinearColourScale);
-	setBinDisplay(PeakFrequencies);
+	setBinDisplay(Colour3DPlotRenderer::PeakFrequencies);
         setNormalization(ColumnOp::NormalizeColumns);
         colourConfigName = "spectrogram-melodic-colour";
         colourConfigDefault = int(ColourMapper::Sunset);
     }
 

 
     } else if (name == "Frequency Scale") {
 
 	*min = 0;
 	*max = 1;
-        *deflt = int(LinearFrequencyScale);
-	val = (int)m_frequencyScale;
+        *deflt = int(Colour3DPlotRenderer::LinearBinScale);
+	val = (int)m_binScale;
 
     } else if (name == "Bin Display") {
 
 	*min = 0;
 	*max = 2;
-        *deflt = int(AllBins);
+        *deflt = int(Colour3DPlotRenderer::AllBins);
 	val = (int)m_binDisplay;
 
     } else if (name == "Normalization") {
 	
         *min = 0;

 	case 4: setColourScale(ColourScale::PhaseColourScale); break;
 	}
     } else if (name == "Frequency Scale") {
 	switch (value) {
 	default:
-	case 0: setFrequencyScale(LinearFrequencyScale); break;
-	case 1: setFrequencyScale(LogFrequencyScale); break;
+	case 0: setBinScale(Colour3DPlotRenderer::LinearBinScale); break;
+	case 1: setBinScale(Colour3DPlotRenderer::LogBinScale); break;
 	}
     } else if (name == "Bin Display") {
 	switch (value) {
 	default:
-	case 0: setBinDisplay(AllBins); break;
-	case 1: setBinDisplay(PeakBins); break;
-	case 2: setBinDisplay(PeakFrequencies); break;
+	case 0: setBinDisplay(Colour3DPlotRenderer::AllBins); break;
+	case 1: setBinDisplay(Colour3DPlotRenderer::PeakBins); break;
+	case 2: setBinDisplay(Colour3DPlotRenderer::PeakFrequencies); break;
 	}
     } else if (name == "Normalization") {
         switch (value) {
         default:
         case 0: setNormalization(ColumnOp::NoNormalization); break;

 }
 
 int
 SpectrogramLayer::getFFTOversampling() const
 {
-    if (m_binDisplay != AllBins) {
+    if (m_binDisplay != Colour3DPlotRenderer::AllBins) {
         return 1;
     }
 
     Preferences::SpectrogramSmoothing smoothing = 
         Preferences::getInstance()->getSpectrogramSmoothing();

 {
     return m_colourMap;
 }
 
 void
-SpectrogramLayer::setFrequencyScale(FrequencyScale frequencyScale)
-{
-    if (m_frequencyScale == frequencyScale) return;
+SpectrogramLayer::setBinScale(Colour3DPlotRenderer::BinScale binScale)
+{
+    if (m_binScale == binScale) return;
 
     invalidateImageCaches();
-    m_frequencyScale = frequencyScale;
+    m_binScale = binScale;
 
     emit layerParametersChanged();
 }
 
-SpectrogramLayer::FrequencyScale
-SpectrogramLayer::getFrequencyScale() const
-{
-    return m_frequencyScale;
-}
-
-void
-SpectrogramLayer::setBinDisplay(BinDisplay binDisplay)
+Colour3DPlotRenderer::BinScale
+SpectrogramLayer::getBinScale() const
+{
+    return m_binScale;
+}
+
+void
+SpectrogramLayer::setBinDisplay(Colour3DPlotRenderer::BinDisplay binDisplay)
 {
     if (m_binDisplay == binDisplay) return;
 
     invalidateImageCaches();
     m_binDisplay = binDisplay;
 
     emit layerParametersChanged();
 }
 
-SpectrogramLayer::BinDisplay
+Colour3DPlotRenderer::BinDisplay
 SpectrogramLayer::getBinDisplay() const
 {
     return m_binDisplay;
 }
 

 
     sv_samplerate_t sr = m_model->getSampleRate();
     double minf = getEffectiveMinFrequency();
     double maxf = getEffectiveMaxFrequency();
 
-    bool logarithmic = (m_frequencyScale == LogFrequencyScale);
+    bool logarithmic = (m_binScale == Colour3DPlotRenderer::LogBinScale);
 
     q0 = v->getFrequencyForY(y, minf, maxf, logarithmic);
     q1 = v->getFrequencyForY(y - 1, minf, maxf, logarithmic);
 
     // Now map these on to ("proportions of") actual bins

 
     sv_samplerate_t sr = m_model->getSampleRate();
     double minf = getEffectiveMinFrequency();
     double maxf = getEffectiveMaxFrequency();
 
-    bool logarithmic = (m_frequencyScale == LogFrequencyScale);
+    bool logarithmic = (m_binScale == Colour3DPlotRenderer::LogBinScale);
 
     double q = v->getFrequencyForY(y, minf, maxf, logarithmic);
 
     // Now map on to ("proportions of") actual bins
 

 
     sv_samplerate_t sr = m_model->getSampleRate();
 
     bool haveAdj = false;
 
-    bool peaksOnly = (m_binDisplay == PeakBins ||
-		      m_binDisplay == PeakFrequencies);
+    bool peaksOnly = (m_binDisplay == Colour3DPlotRenderer::PeakBins ||
+		      m_binDisplay == Colour3DPlotRenderer::PeakFrequencies);
 
     for (int q = q0i; q <= q1i; ++q) {
 
 	for (int s = s0i; s <= s1i; ++s) {
 

 }
 
 void
 SpectrogramLayer::paintAlternative(LayerGeometryProvider *v, QPainter &paint, QRect rect) const
 {
+    static int depth = 0;
+    
     Colour3DPlotRenderer *renderer = getRenderer(v);
 
     if (m_synchronous) {
         (void)renderer->render(v, paint, rect);
         return;
     }
+
+    ++depth;
+    cerr << "paint depth " << depth << endl;
     
     Colour3DPlotRenderer::RenderResult result =
         renderer->renderTimeConstrained(v, paint, rect);
 
     //!!! + mag range
 
     QRect rendered = result.rendered;
-    if (rendered == rect) return;
+    if (rendered == rect) {
+        cerr << "exiting paint depth " << depth << endl;
+        --depth;
+        return;
+    }
 
     int rLeft = rendered.x();
     int rRight = rendered.x() + rendered.width();
 
     if (rLeft < rect.x()) {

     QRect areaRight(rRight, rect.y(),
                     rect.x() + rect.width() - rRight, rect.height());
     
     bool updateLeft = (areaLeft.width() > 0);
     bool updateRight = (areaRight.width() > 0);
-            
+
     if (updateLeft) {
         if (updateRight) {
             if (areaLeft.width() > areaRight.width()) {
+                cerr << "update left then right, widths "
+                     << areaLeft.width() << " and "
+                     << areaRight.width() << endl;
                 v->updatePaintRect(areaLeft);
                 v->updatePaintRect(areaRight);
             } else {
+                cerr << "update right then left, widths "
+                     << areaLeft.width() << " and "
+                     << areaRight.width() << endl;
                 v->updatePaintRect(areaRight);
                 v->updatePaintRect(areaLeft);
             }
         } else {
+            cerr << "update left, width " << areaLeft.width() << endl;
             v->updatePaintRect(areaLeft);
         }
     } else {
+        cerr << "update right, width " << areaRight.width() << endl;
         v->updatePaintRect(areaRight);
-    }        
+    }
+
+    cerr << "exiting paint depth " << depth << endl;
+    --depth;
 }
 
 Colour3DPlotRenderer *
 SpectrogramLayer::getRenderer(LayerGeometryProvider *v) const
 {

         sources.peaks = getPeakCache();
 
         ColourScale::Parameters cparams;
         cparams.colourMap = m_colourMap;
         cparams.scale = m_colourScale;
+        cparams.threshold = m_threshold;
+        cparams.gain = m_gain;
+
+        if (m_colourScale != ColourScale::PhaseColourScale &&
+            m_normalization == ColumnOp::NoNormalization) {
+            cparams.gain *= 2.f / float(getFFTSize());
+        }
         
         Colour3DPlotRenderer::Parameters params;
         params.colourScale = ColourScale(cparams);
         params.normalization = m_normalization;
-        //!!! map properly:
-        params.binDisplay = (Colour3DPlotRenderer::BinDisplay)(int)m_binDisplay;
-        params.binScale = (Colour3DPlotRenderer::BinScale)(int)m_frequencyScale;
-        //!!! and the rest
+        params.binDisplay = m_binDisplay;
+        params.binScale = m_binScale;
+        params.alwaysOpaque = true;
+        params.invertVertical = false;
+
+        Preferences::SpectrogramSmoothing smoothing = 
+            Preferences::getInstance()->getSpectrogramSmoothing();
+        params.interpolate = 
+            (smoothing == Preferences::SpectrogramInterpolated ||
+             smoothing == Preferences::SpectrogramZeroPaddedAndInterpolated);
 
         m_renderers[v->getId()] = new Colour3DPlotRenderer(sources, params);
     }
 
     return m_renderers[v->getId()];

 
 //    cerr << "(giving actual minFreq " << minFreq << " and display minFreq " << displayMinFreq << ")" << endl;
 
     int increment = getWindowIncrement();
     
-    bool logarithmic = (m_frequencyScale == LogFrequencyScale);
+    bool logarithmic = (m_binScale == Colour3DPlotRenderer::LogBinScale);
 
     MagnitudeRange overallMag = m_viewMags[v->getId()];
     bool overallMagChanged = false;
 
 #ifdef DEBUG_SPECTROGRAM_REPAINT

 
     } else {
 
         // neither limitation applies, so use a short soft limit
 
-        if (m_binDisplay == PeakFrequencies) {
+        if (m_binDisplay == Colour3DPlotRenderer::PeakFrequencies) {
             softTimeLimit = 0.15;
         } else {
             softTimeLimit = 0.1;
         }
     }
 
-    if (m_binDisplay != PeakFrequencies) {
+    if (m_binDisplay != Colour3DPlotRenderer::PeakFrequencies) {
 
         for (int y = 0; y < h; ++y) {
             double q0 = 0, q1 = 0;
             if (!getYBinRange(v, h-y-1, q0, q1)) {
                 binfory[y] = -1;

     bool interpolate = false;
     Preferences::SpectrogramSmoothing smoothing = 
         Preferences::getInstance()->getSpectrogramSmoothing();
     if (smoothing == Preferences::SpectrogramInterpolated ||
         smoothing == Preferences::SpectrogramZeroPaddedAndInterpolated) {
-        if (m_binDisplay != PeakBins &&
-            m_binDisplay != PeakFrequencies) {
+        if (m_binDisplay != Colour3DPlotRenderer::PeakBins &&
+            m_binDisplay != Colour3DPlotRenderer::PeakFrequencies) {
             interpolate = true;
         }
     }
 
     int psx = -1;

 
                 if (m_colourScale != ColourScale::PhaseColourScale) {
                     column = ColumnOp::normalize(column, m_normalization);
                 }
 
-                if (m_binDisplay == PeakBins) {
+                if (m_binDisplay == Colour3DPlotRenderer::PeakBins) {
                     column = ColumnOp::peakPick(column);
                 }
 
                 preparedColumn =
                     ColumnOp::distribute(ColumnOp::applyGain(column, m_gain),

 SpectrogramLayer::getYForFrequency(const LayerGeometryProvider *v, double frequency) const
 {
     return v->getYForFrequency(frequency,
 			       getEffectiveMinFrequency(),
 			       getEffectiveMaxFrequency(),
-			       m_frequencyScale == LogFrequencyScale);
+			       m_binScale == Colour3DPlotRenderer::LogBinScale);
 }
 
 double
 SpectrogramLayer::getFrequencyForY(const LayerGeometryProvider *v, int y) const
 {
     return v->getFrequencyForY(y,
 			       getEffectiveMinFrequency(),
 			       getEffectiveMaxFrequency(),
-			       m_frequencyScale == LogFrequencyScale);
+			       m_binScale == Colour3DPlotRenderer::LogBinScale);
 }
 
 int
 SpectrogramLayer::getCompletion(LayerGeometryProvider *) const
 {

 
     sv_samplerate_t sr = m_model->getSampleRate();
     min = double(sr) / getFFTSize();
     max = double(sr) / 2;
     
-    logarithmic = (m_frequencyScale == LogFrequencyScale);
+    logarithmic = (m_binScale == Colour3DPlotRenderer::LogBinScale);
     unit = "Hz";
     return true;
 }
 
 bool

 	haveValues = true;
     }
 
     QString adjFreqText = "", adjPitchText = "";
 
-    if (m_binDisplay == PeakFrequencies) {
+    if (m_binDisplay == Colour3DPlotRenderer::PeakFrequencies) {
 
 	if (!getAdjustedYBinSourceRange(v, x, y, freqMin, freqMax,
 					adjFreqMin, adjFreqMax)) {
 	    return "";
 	}

 					  m_model->getSampleRate() / 2));
 
     int fw = paint.fontMetrics().width(tr("43Hz"));
     if (tw < fw) tw = fw;
 
-    int tickw = (m_frequencyScale == LogFrequencyScale ? 10 : 4);
+    int tickw = (m_binScale == Colour3DPlotRenderer::LogBinScale ? 10 : 4);
     
     return cw + tickw + tw + 13;
 }
 
 void

 
     //!!! cache this?
 
     int h = rect.height(), w = rect.width();
 
-    int tickw = (m_frequencyScale == LogFrequencyScale ? 10 : 4);
-    int pkw = (m_frequencyScale == LogFrequencyScale ? 10 : 0);
+    int tickw = (m_binScale == Colour3DPlotRenderer::LogBinScale ? 10 : 4);
+    int pkw = (m_binScale == Colour3DPlotRenderer::LogBinScale ? 10 : 0);
 
     int bins = getFFTSize() / 2;
     sv_samplerate_t sr = m_model->getSampleRate();
 
     if (m_maxFrequency > 0) {

 	}
 
 	int freq = int((sr * bin) / getFFTSize());
 
 	if (py >= 0 && (vy - py) < textHeight - 1) {
-	    if (m_frequencyScale == LinearFrequencyScale) {
+	    if (m_binScale == Colour3DPlotRenderer::LinearBinScale) {
 		paint.drawLine(w - tickw, h - vy, w, h - vy);
 	    }
 	    continue;
 	}
 

 	}
 
 	py = vy;
     }
 
-    if (m_frequencyScale == LogFrequencyScale) {
+    if (m_binScale == Colour3DPlotRenderer::LogBinScale) {
 
         // piano keyboard
 
         PianoScale().paintPianoVertical
             (v, paint, QRect(w - pkw - 1, 0, pkw, h),

     SpectrogramRangeMapper mapper(sr, getFFTSize());
     double newdist = mapper.getValueForPosition(step);
 
     double newmin, newmax;
 
-    if (m_frequencyScale == LogFrequencyScale) {
+    if (m_binScale == Colour3DPlotRenderer::LogBinScale) {
 
         // need to pick newmin and newmax such that
         //
         // (log(newmin) + log(newmax)) / 2 == logmid
         // and

 	.arg(m_minFrequency)
 	.arg(m_maxFrequency)
 	.arg(convertOutColourScale(m_colourScale))
 	.arg(m_colourMap)
 	.arg(m_colourRotation)
-	.arg(m_frequencyScale)
+	.arg(m_binScale)
 	.arg(m_binDisplay);
 
     // 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

     if (ok) setColourMap(colourMap);
 
     int colourRotation = attributes.value("colourRotation").toInt(&ok);
     if (ok) setColourRotation(colourRotation);
 
-    FrequencyScale frequencyScale = (FrequencyScale)
+    Colour3DPlotRenderer::BinScale binScale = (Colour3DPlotRenderer::BinScale)
 	attributes.value("frequencyScale").toInt(&ok);
-    if (ok) setFrequencyScale(frequencyScale);
-
-    BinDisplay binDisplay = (BinDisplay)
+    if (ok) setBinScale(binScale);
+
+    Colour3DPlotRenderer::BinDisplay binDisplay = (Colour3DPlotRenderer::BinDisplay)
 	attributes.value("binDisplay").toInt(&ok);
     if (ok) setBinDisplay(binDisplay);
 
     bool haveNewStyleNormalization = false;