comparison layer/SpectrogramLayer.cpp @ 706:97ea68f62c1f imaf_enc

Merge from default branch

 #include "base/LogRange.h"
 #include "widgets/CommandHistory.h"
 #include "ColourMapper.h"
 #include "ImageRegionFinder.h"
 #include "data/model/Dense3DModelPeakCache.h"
+#include "PianoScale.h"
 
 #include <QPainter>
 #include <QImage>
 #include <QPixmap>
 #include <QRect>

 #include <QMouseEvent>
 #include <QTextStream>
 
 #include <iostream>
 
-using std::cerr;
-using std::endl;
+
+
 #include <cassert>
 #include <cmath>
 
 #ifndef __GNUC__
 #include <alloca.h>

 }
 
 void
 SpectrogramLayer::setModel(const DenseTimeValueModel *model)
 {
-//    std::cerr << "SpectrogramLayer(" << this << "): setModel(" << model << ")" << std::endl;
+//    cerr << "SpectrogramLayer(" << this << "): setModel(" << model << ")" << endl;
 
     if (model == m_model) return;
 
     m_model = model;
     invalidateFFTModels();

         SVDEBUG << "SpectrogramLayer::invalidateImageCaches(" 
                   << startFrame << ", " << endFrame << "): view range is "
                   << v->getStartFrame() << ", " << v->getEndFrame()
                   << endl;
 
-        std::cerr << "Valid area was: " << i->second.validArea.x() << ", "
+        cerr << "Valid area was: " << i->second.validArea.x() << ", "
                   << i->second.validArea.y() << " "
                   << i->second.validArea.width() << "x"
-                  << i->second.validArea.height() << std::endl;
+                  << i->second.validArea.height() << endl;
 #endif
 
         if (long(startFrame) > v->getStartFrame()) {
             if (startFrame >= v->getEndFrame()) {
 #ifdef DEBUG_SPECTROGRAM_REPAINT
-                std::cerr << "Modified start frame is off right of view" << std::endl;
+                cerr << "Modified start frame is off right of view" << endl;
 #endif
                 return;
             }
             int x = v->getXForFrame(startFrame);
 #ifdef DEBUG_SPECTROGRAM_REPAINT

                 i->second.validArea = QRect();
             }
         } else {
             if (long(endFrame) < v->getStartFrame()) {
 #ifdef DEBUG_SPECTROGRAM_REPAINT
-                std::cerr << "Modified end frame is off left of view" << std::endl;
+                cerr << "Modified end frame is off left of view" << endl;
 #endif
                 return;
             }
             int x = v->getXForFrame(endFrame);
 #ifdef DEBUG_SPECTROGRAM_REPAINT

                 i->second.validArea = QRect();
             }
         }
 
 #ifdef DEBUG_SPECTROGRAM_REPAINT
-        std::cerr << "Valid area is now: " << i->second.validArea.x() << ", "
+        cerr << "Valid area is now: " << i->second.validArea.x() << ", "
                   << i->second.validArea.y() << " "
                   << i->second.validArea.width() << "x"
-                  << i->second.validArea.height() << std::endl;
+                  << i->second.validArea.height() << endl;
 #endif
     }
 }
 
 void

 #endif
 
             if (fill >= lastFill) {
                 if (fill >= m_model->getEndFrame() && lastFill > 0) {
 #ifdef DEBUG_SPECTROGRAM_REPAINT
-                    std::cerr << "complete!" << std::endl;
+                    cerr << "complete!" << endl;
 #endif
                     invalidateImageCaches();
                     i->second.second = -1;
                     emit modelChanged();
 
                 } else if (fill > lastFill) {
 #ifdef DEBUG_SPECTROGRAM_REPAINT
-                    std::cerr << "SpectrogramLayer: emitting modelChanged("
-                              << lastFill << "," << fill << ")" << std::endl;
+                    cerr << "SpectrogramLayer: emitting modelChanged("
+                              << lastFill << "," << fill << ")" << endl;
 #endif
                     invalidateImageCaches(lastFill, fill);
                     i->second.second = fill;
                     emit modelChanged(lastFill, fill);
                 }
             } else {
 #ifdef DEBUG_SPECTROGRAM_REPAINT
-                std::cerr << "SpectrogramLayer: going backwards, emitting modelChanged("
-                          << m_model->getStartFrame() << "," << m_model->getEndFrame() << ")" << std::endl;
+                cerr << "SpectrogramLayer: going backwards, emitting modelChanged("
+                          << m_model->getStartFrame() << "," << m_model->getEndFrame() << ")" << endl;
 #endif
                 invalidateImageCaches();
                 i->second.second = fill;
                 emit modelChanged(m_model->getStartFrame(), m_model->getEndFrame());
             }

         }
     }
 
     if (allDone) {
 #ifdef DEBUG_SPECTROGRAM_REPAINT
-        std::cerr << "SpectrogramLayer: all complete!" << std::endl;
+        cerr << "SpectrogramLayer: all complete!" << endl;
 #endif
         delete m_updateTimer;
         m_updateTimer = 0;
     }
 }

             return 0;
         }
 
         if (!m_sliceableModel) {
 #ifdef DEBUG_SPECTROGRAM
-            std::cerr << "SpectrogramLayer: emitting sliceableModelReplaced(0, " << model << ")" << std::endl;
+            cerr << "SpectrogramLayer: emitting sliceableModelReplaced(0, " << model << ")" << endl;
 #endif
             ((SpectrogramLayer *)this)->sliceableModelReplaced(0, model);
             m_sliceableModel = model;
         }
 

     
     m_fftModels.clear();
     m_peakCaches.clear();
 
     if (m_sliceableModel) {
-        std::cerr << "SpectrogramLayer: emitting sliceableModelReplaced(" << m_sliceableModel << ", 0)" << std::endl;
+        cerr << "SpectrogramLayer: emitting sliceableModelReplaced(" << m_sliceableModel << ", 0)" << endl;
         emit sliceableModelReplaced(m_sliceableModel, 0);
         m_sliceableModel = 0;
     }
 }
 

     Profiler profiler("SpectrogramLayer::paint", false);
 
 #ifdef DEBUG_SPECTROGRAM_REPAINT
     SVDEBUG << "SpectrogramLayer::paint(): m_model is " << m_model << ", zoom level is " << v->getZoomLevel() << ", m_updateTimer " << m_updateTimer << endl;
     
-    std::cerr << "rect is " << rect.x() << "," << rect.y() << " " << rect.width() << "x" << rect.height() << std::endl;
+    cerr << "rect is " << rect.x() << "," << rect.y() << " " << rect.width() << "x" << rect.height() << endl;
 #endif
 
     long startFrame = v->getStartFrame();
     if (startFrame < 0) m_candidateFillStartFrame = 0;
     else m_candidateFillStartFrame = startFrame;

 
     size_t fftSize = getFFTSize(v);
 /*
     FFTModel *fft = getFFTModel(v);
     if (!fft) {
-	std::cerr << "ERROR: SpectrogramLayer::paint(): No FFT model, returning" << std::endl;
+	cerr << "ERROR: SpectrogramLayer::paint(): No FFT model, returning" << endl;
 	return;
     }
 */
     ImageCache &cache = m_imageCaches[v];
 

 
     x0 = rect.left();
     x1 = rect.right() + 1;
 /*
     float xPixelRatio = float(fft->getResolution()) / float(zoomLevel);
-    std::cerr << "xPixelRatio = " << xPixelRatio << std::endl;
+    cerr << "xPixelRatio = " << xPixelRatio << endl;
     if (xPixelRatio < 1.f) xPixelRatio = 1.f;
 */
     if (cache.validArea.width() > 0) {
 
         int cw = cache.image.width();

 		v->getXForFrame(startFrame) &&
                 cache.validArea.x() <= x0 &&
                 cache.validArea.x() + cache.validArea.width() >= x1) {
 	    
 #ifdef DEBUG_SPECTROGRAM_REPAINT
-		std::cerr << "SpectrogramLayer: image cache good" << std::endl;
+		cerr << "SpectrogramLayer: image cache good" << endl;
 #endif
 
 		paint.drawImage(rect, cache.image, rect);
                 //!!!
 //                paint.drawImage(v->rect(), cache.image,

 		return;
 
 	    } else {
 
 #ifdef DEBUG_SPECTROGRAM_REPAINT
-		std::cerr << "SpectrogramLayer: image cache partially OK" << std::endl;
+		cerr << "SpectrogramLayer: image cache partially OK" << endl;
 #endif
 
 		recreateWholeImageCache = false;
 
 		int dx = v->getXForFrame(cache.startFrame) -
 		         v->getXForFrame(startFrame);
 
 #ifdef DEBUG_SPECTROGRAM_REPAINT
-		std::cerr << "SpectrogramLayer: dx = " << dx << " (image cache " << cw << "x" << ch << ")" << std::endl;
+		cerr << "SpectrogramLayer: dx = " << dx << " (image cache " << cw << "x" << ch << ")" << endl;
 #endif
 
 		if (dx != 0 &&
                     dx > -cw &&
                     dx <  cw) {

                     cache.validArea =
                         QRect(px, cache.validArea.y(),
                               pw, cache.validArea.height());
 
 #ifdef DEBUG_SPECTROGRAM_REPAINT
-                    std::cerr << "valid area now "
+                    cerr << "valid area now "
                               << px << "," << cache.validArea.y()
                               << " " << pw << "x" << cache.validArea.height()
-                              << std::endl;
+                              << endl;
 #endif
 /*
 		    paint.drawImage(rect & cache.validArea,
                                      cache.image,
                                      rect & cache.validArea);

                 } else if (dx != 0) {
 
                     // we scrolled too far to be of use
 
 #ifdef DEBUG_SPECTROGRAM_REPAINT
-                    std::cerr << "dx == " << dx << ": scrolled too far for cache to be useful" << std::endl;
+                    cerr << "dx == " << dx << ": scrolled too far for cache to be useful" << endl;
 #endif
 
                     cache.validArea = QRect();
                     recreateWholeImageCache = true;
                 }
 	    }
 	} else {
 #ifdef DEBUG_SPECTROGRAM_REPAINT
-	    std::cerr << "SpectrogramLayer: image cache useless" << std::endl;
+	    cerr << "SpectrogramLayer: image cache useless" << endl;
             if (int(cache.zoomLevel) != zoomLevel) {
-                std::cerr << "(cache zoomLevel " << cache.zoomLevel
-                          << " != " << zoomLevel << ")" << std::endl;
+                cerr << "(cache zoomLevel " << cache.zoomLevel
+                          << " != " << zoomLevel << ")" << endl;
             }
             if (cw != v->width()) {
-                std::cerr << "(cache width " << cw
+                cerr << "(cache width " << cw
                           << " != " << v->width();
             }
             if (ch != v->height()) {
-                std::cerr << "(cache height " << ch
+                cerr << "(cache height " << ch
                           << " != " << v->height();
             }
 #endif
             cache.validArea = QRect();
 //            recreateWholeImageCache = true;
 	}
     }
 
     if (updateViewMagnitudes(v)) {
 #ifdef DEBUG_SPECTROGRAM_REPAINT
-        std::cerr << "SpectrogramLayer: magnitude range changed to [" << m_viewMags[v].getMin() << "->" << m_viewMags[v].getMax() << "]" << std::endl;
+        cerr << "SpectrogramLayer: magnitude range changed to [" << m_viewMags[v].getMin() << "->" << m_viewMags[v].getMax() << "]" << endl;
 #endif
         if (m_normalizeVisibleArea) {
             cache.validArea = QRect();
             recreateWholeImageCache = true;
         }
     } else {
 #ifdef DEBUG_SPECTROGRAM_REPAINT
-        std::cerr << "No change in magnitude range [" << m_viewMags[v].getMin() << "->" << m_viewMags[v].getMax() << "]" << std::endl;
+        cerr << "No change in magnitude range [" << m_viewMags[v].getMin() << "->" << m_viewMags[v].getMax() << "]" << endl;
 #endif
     }
 
     if (recreateWholeImageCache) {
         x0 = 0;

         
         if (paintBlockWidth < 20) paintBlockWidth = 20;
     }
 
 #ifdef DEBUG_SPECTROGRAM_REPAINT
-    std::cerr << "[" << this << "]: last paint width: " << m_lastPaintBlockWidth << ", last paint time: " << m_lastPaintTime << ", new paint width: " << paintBlockWidth << std::endl;
+    cerr << "[" << this << "]: last paint width: " << m_lastPaintBlockWidth << ", last paint time: " << m_lastPaintTime << ", new paint width: " << paintBlockWidth << endl;
 #endif
 
     // We always paint the full height when refreshing the cache.
     // Smaller heights can be used when painting direct from cache
     // (further up in this function), but we want to ensure the cache

         int vx0 = 0, vx1 = 0;
         vx0 = cache.validArea.x();
         vx1 = cache.validArea.x() + cache.validArea.width();
         
 #ifdef DEBUG_SPECTROGRAM_REPAINT
-        std::cerr << "x0 " << x0 << ", x1 " << x1 << ", vx0 " << vx0 << ", vx1 " << vx1 << ", paintBlockWidth " << paintBlockWidth << std::endl;
+        cerr << "x0 " << x0 << ", x1 " << x1 << ", vx0 " << vx0 << ", vx1 " << vx1 << ", paintBlockWidth " << paintBlockWidth << endl;
 #endif         
         if (x0 < vx0) {
             if (x0 + paintBlockWidth < vx0) {
                 x0 = vx0 - paintBlockWidth;
             }

              std::max(vx1 - std::min(vx0, x0),
                        x1 - std::min(vx0, x0)),
              cache.validArea.height());
 
 #ifdef DEBUG_SPECTROGRAM_REPAINT
-        std::cerr << "Valid area becomes " << cache.validArea.x()
+        cerr << "Valid area becomes " << cache.validArea.x()
                   << ", " << cache.validArea.y() << ", "
                   << cache.validArea.width() << "x"
-                  << cache.validArea.height() << std::endl;
+                  << cache.validArea.height() << endl;
 #endif
             
     } else {
         if (x1 > x0 + paintBlockWidth) {
             int sfx = x1;

                 x0 = mid - paintBlockWidth/2;
                 x1 = x0 + paintBlockWidth;
             }
         }
 #ifdef DEBUG_SPECTROGRAM_REPAINT
-        std::cerr << "Valid area becomes " << x0 << ", 0, " << (x1-x0)
-                  << "x" << h << std::endl;
+        cerr << "Valid area becomes " << x0 << ", 0, " << (x1-x0)
+                  << "x" << h << endl;
 #endif
         cache.validArea = QRect(x0, 0, x1 - x0, h);
     }
 
 /*

     }
 */
     int w = x1 - x0;
 
 #ifdef DEBUG_SPECTROGRAM_REPAINT
-    std::cerr << "x0 " << x0 << ", x1 " << x1 << ", w " << w << ", h " << h << std::endl;
+    cerr << "x0 " << x0 << ", x1 " << x1 << ", w " << w << ", h " << h << endl;
 #endif
 
     int sr = m_model->getSampleRate();
 
     // Set minFreq and maxFreq to the frequency extents of the possibly

     }
 
     size_t minbin = 1;
     if (m_minFrequency > 0) {
 	minbin = int((double(m_minFrequency) * m_fftSize) / sr + 0.001);
-//        std::cerr << "m_minFrequency = " << m_minFrequency << " -> minbin = " << minbin << std::endl;
+//        cerr << "m_minFrequency = " << m_minFrequency << " -> minbin = " << minbin << endl;
 	if (minbin < 1) minbin = 1;
 	if (minbin >= maxbin) minbin = maxbin - 1;
     }
 
     int zpl = getZeroPadLevel(v) + 1;

     if (fftSize != m_fftSize) {
         displayMinFreq = getEffectiveMinFrequency();
         displayMaxFreq = getEffectiveMaxFrequency();
     }
 
-//    std::cerr << "(giving actual minFreq " << minFreq << " and display minFreq " << displayMinFreq << ")" << std::endl;
+//    cerr << "(giving actual minFreq " << minFreq << " and display minFreq " << displayMinFreq << ")" << endl;
 
     int increment = getWindowIncrement();
     
     bool logarithmic = (m_frequencyScale == LogFrequencyScale);
 /*

     bool overallMagChanged = false;
 
     bool fftSuspended = false;
 
 #ifdef DEBUG_SPECTROGRAM_REPAINT
-    std::cerr << ((float(v->getFrameForX(1) - v->getFrameForX(0))) / increment) << " bin(s) per pixel" << std::endl;
+    cerr << ((float(v->getFrameForX(1) - v->getFrameForX(0))) / increment) << " bin(s) per pixel" << endl;
 #endif
 
     bool runOutOfData = false;
 
     if (w == 0) {

                                           xPixelRatio,
                                           h, yforbin);
 
         if (runOutOfData) {
 #ifdef DEBUG_SPECTROGRAM_REPAINT
-            std::cerr << "Run out of data -- dropping out of loop" << std::endl;
+            cerr << "Run out of data -- dropping out of loop" << endl;
 #endif
             break;
         }
     }
 */
 #ifdef DEBUG_SPECTROGRAM_REPAINT
-//    std::cerr << pixels << " pixels drawn" << std::endl;
+//    cerr << pixels << " pixels drawn" << endl;
 #endif
 
     if (overallMagChanged) {
         m_viewMags[v] = overallMag;
 #ifdef DEBUG_SPECTROGRAM_REPAINT
-        std::cerr << "Overall mag is now [" << m_viewMags[v].getMin() << "->" << m_viewMags[v].getMax() << "] - will be updating" << std::endl;
+        cerr << "Overall mag is now [" << m_viewMags[v].getMin() << "->" << m_viewMags[v].getMax() << "] - will be updating" << endl;
 #endif
     } else {
 #ifdef DEBUG_SPECTROGRAM_REPAINT
-        std::cerr << "Overall mag unchanged at [" << m_viewMags[v].getMin() << "->" << m_viewMags[v].getMax() << "]" << std::endl;
+        cerr << "Overall mag unchanged at [" << m_viewMags[v].getMin() << "->" << m_viewMags[v].getMax() << "]" << endl;
 #endif
     }
 
     outerprof.end();
 

                                                   cache.validArea.width()),
                           h);
             }
         } else {
             // overallMagChanged
-            std::cerr << "\noverallMagChanged - updating all\n" << std::endl;
+            cerr << "\noverallMagChanged - updating all\n" << endl;
             cache.validArea = QRect();
             v->update();
         }
     }
 

             if (sx < 0 || sx >= int(fft->getWidth())) continue;
 
             if (!m_synchronous) {
                 if (!fft->isColumnAvailable(sx)) {
 #ifdef DEBUG_SPECTROGRAM_REPAINT
-                    std::cerr << "Met unavailable column at col " << sx << std::endl;
+                    cerr << "Met unavailable column at col " << sx << endl;
 #endif
                     return false;
                 }
             }
 

             }
 
             if (mag.isSet()) {
                 if (sx >= int(m_columnMags.size())) {
 #ifdef DEBUG_SPECTROGRAM
-                    std::cerr << "INTERNAL ERROR: " << sx << " >= "
+                    cerr << "INTERNAL ERROR: " << sx << " >= "
                               << m_columnMags.size()
                               << " at SpectrogramLayer.cpp::paintDrawBuffer"
-                              << std::endl;
+                              << endl;
 #endif
                 } else {
                     m_columnMags[sx].sample(mag);
                     if (overallMag.sample(mag)) overallMagChanged = true;
                 }

         for (int y = 0; y < h; ++y) peaks[y] = 0.f;
             
         for (int sx = sx0; sx < sx1; ++sx) {
 
 #ifdef DEBUG_SPECTROGRAM_REPAINT
-//            std::cerr << "sx = " << sx << std::endl;
+//            cerr << "sx = " << sx << endl;
 #endif
 
             if (sx < 0 || sx >= int(sourceModel->getWidth())) continue;
 
             if (!m_synchronous) {
                 if (!sourceModel->isColumnAvailable(sx)) {
 #ifdef DEBUG_SPECTROGRAM_REPAINT
-                    std::cerr << "Met unavailable column at col " << sx << std::endl;
+                    cerr << "Met unavailable column at col " << sx << endl;
 #endif
                     return false;
                 }
             }
 

             }
 
             if (mag.isSet()) {
                 if (sx >= int(m_columnMags.size())) {
 #ifdef DEBUG_SPECTROGRAM
-                    std::cerr << "INTERNAL ERROR: " << sx << " >= "
+                    cerr << "INTERNAL ERROR: " << sx << " >= "
                               << m_columnMags.size()
                               << " at SpectrogramLayer.cpp::paintDrawBuffer"
-                              << std::endl;
+                              << endl;
 #endif
                 } else {
                     m_columnMags[sx].sample(mag);
                     if (overallMag.sample(mag)) overallMagChanged = true;
                 }

     QPoint localPos;
     if (!v->shouldIlluminateLocalFeatures(this, localPos) || !m_model) {
         return;
     }
 
-//    std::cerr << "SpectrogramLayer: illuminateLocalFeatures("
-//              << localPos.x() << "," << localPos.y() << ")" << std::endl;
+//    cerr << "SpectrogramLayer: illuminateLocalFeatures("
+//              << localPos.x() << "," << localPos.y() << ")" << endl;
 
     float s0, s1;
     float f0, f1;
 
     if (getXBinRange(v, localPos.x(), s0, s1) &&

         int x1 = v->getXForFrame((s1i + 1) * getWindowIncrement());
 
         int y1 = int(getYForFrequency(v, f1));
         int y0 = int(getYForFrequency(v, f0));
         
-//        std::cerr << "SpectrogramLayer: illuminate "
-//                  << x0 << "," << y1 << " -> " << x1 << "," << y0 << std::endl;
+//        cerr << "SpectrogramLayer: illuminate "
+//                  << x0 << "," << y1 << " -> " << x1 << "," << y0 << endl;
         
         paint.setPen(v->getForeground());
 
         //!!! should we be using paintCrosshairs for this?
 

 void
 SpectrogramLayer::measureDoubleClick(View *v, QMouseEvent *e)
 {
     ImageCache &cache = m_imageCaches[v];
 
-    std::cerr << "cache width: " << cache.image.width() << ", height: "
-              << cache.image.height() << std::endl;
+    cerr << "cache width: " << cache.image.width() << ", height: "
+              << cache.image.height() << endl;
 
     QImage image = cache.image;
 
     ImageRegionFinder finder;
     QRect rect = finder.findRegionExtents(&image, e->pos());

 
     if (m_frequencyScale == LogFrequencyScale) {
 
         // piano keyboard
 
-	paint.drawLine(w - pkw - 1, 0, w - pkw - 1, h);
-
-	float minf = getEffectiveMinFrequency();
-	float maxf = getEffectiveMaxFrequency();
-
-	int py = h, ppy = h;
-	paint.setBrush(paint.pen().color());
-
-	for (int i = 0; i < 128; ++i) {
-
-	    float f = Pitch::getFrequencyForPitch(i);
-	    int y = lrintf(v->getYForFrequency(f, minf, maxf, true));
-
-            if (y < -2) break;
-            if (y > h + 2) {
-                continue;
-            }
-
-	    int n = (i % 12);
-
-            if (n == 1) {
-                // C# -- fill the C from here
-                QColor col = Qt::gray;
-                if (i == 61) { // filling middle C
-                    col = Qt::blue;
-                    col = col.light(150);
-                }
-                if (ppy - y > 2) {
-                    paint.fillRect(w - pkw,
-                                   y,
-                                   pkw,
-                                   (py + ppy) / 2 - y,
-                                   col);
-                }
-            }
-
-	    if (n == 1 || n == 3 || n == 6 || n == 8 || n == 10) {
-		// black notes
-		paint.drawLine(w - pkw, y, w, y);
-		int rh = ((py - y) / 4) * 2;
-		if (rh < 2) rh = 2;
-		paint.drawRect(w - pkw, y - (py-y)/4, pkw/2, rh);
-	    } else if (n == 0 || n == 5) {
-		// C, F
-		if (py < h) {
-		    paint.drawLine(w - pkw, (y + py) / 2, w, (y + py) / 2);
-		}
-	    }
-
-            ppy = py;
-	    py = y;
-	}
+        PianoScale().paintPianoVertical
+            (v, paint, QRect(w - pkw - 1, 0, pkw, h),
+             getEffectiveMinFrequency(), getEffectiveMaxFrequency());
     }
 
     m_haveDetailedScale = detailed;
 }
 

     if (!m_model) return;
 
     float dmin = m_minFrequency, dmax = m_maxFrequency;
 //    getDisplayExtents(dmin, dmax);
 
-//    std::cerr << "current range " << dmin << " -> " << dmax << ", range " << dmax-dmin << ", mid " << (dmax + dmin)/2 << std::endl;
+//    cerr << "current range " << dmin << " -> " << dmax << ", range " << dmax-dmin << ", mid " << (dmax + dmin)/2 << endl;
     
     int sr = m_model->getSampleRate();
     SpectrogramRangeMapper mapper(sr, m_fftSize);
     float newdist = mapper.getValueForPosition(step);
 

         // so newmax = (newdist + sqrtf(newdist^2 + 4dmin.dmax)) / 2
 
         newmax = (newdist + sqrtf(newdist*newdist + 4*dmin*dmax)) / 2;
         newmin = newmax - newdist;
 
-//        std::cerr << "newmin = " << newmin << ", newmax = " << newmax << std::endl;
+//        cerr << "newmin = " << newmin << ", newmax = " << newmax << endl;
 
     } else {
         float dmid = (dmax + dmin) / 2;
         newmin = dmid - newdist / 2;
         newmax = dmid + newdist / 2;