comparison layer/SliceLayer.cpp @ 1394:4a36f6130056 spectrogramparam

Various tweaks & fixes to log-scale handling in spectrum. We can't easily preserve the nice behaviour where peaks stay in place as fft size changes, without potentially losing a bit of low-frequency information

 SliceLayer::getXForScalePoint(const LayerGeometryProvider *v,
                               double p, double pmin, double pmax) const
 {
     double x = 0;
 
-    p -= pmin;
-    if (p < 0) p = 0;
-
-    double extent = pmax - pmin;
-    if (extent < 0) extent = 0;
-
     int pw = v->getPaintWidth();
     int origin = m_xorigins[v->getId()];
     int w = pw - origin;
     if (w < 1) w = 1;
 
-    switch (m_binScale) {
-
-    case LinearBins:
-        x = (w * p) / extent;
-        break;
-        
-    case LogBins:
+    if (p < pmin) p = pmin;
+    if (p > pmax) p = pmax;
+    
+    if (m_binScale == LinearBins) {
+        x = (w * (p - pmin)) / (pmax - pmin);
+    } else {
+
+        if (m_binScale == InvertedLogBins) {
+            // stoopid
+            p = pmax - p;
+        }
+        
         // The 0.8 here is an awkward compromise. Our x-coord is
         // proportional to log of bin number, with the x-coord "of a
         // bin" being that of the left edge of the bin range. We can't
         // start counting bins from 0, as that would give us x = -Inf
         // and hide the first bin entirely. But if we start from 1, we

         // for that bin is in the middle of it. Yet in some modes
         // we'll still want it. A compromise is to count our first bin
         // as "a bit less than 1", so that most of it is visible but a
         // bit is tactfully cropped at the left edge so it doesn't
         // take up so much space.
-        x = (w * log10(p + 0.8)) / log10(extent + 0.8);
-        break;
-        
-    case InvertedLogBins:
-        x = w - (w * log10(extent - p - 1)) / log10(extent);
-        break;
+        const double origin = 0.8;
+        
+        // sometimes we are called with a pmin/pmax range that begins
+        // before 0: in that situation, we shift everything along by
+        // the difference between 0 and pmin before doing any other
+        // calculations
+        double reqdshift = 0.0;
+        if (pmin < 0) reqdshift = -pmin;
+
+        double pminlog = log10(pmin + reqdshift + origin);
+        double pmaxlog = log10(pmax + reqdshift + origin);
+        double plog = log10(p + reqdshift + origin);
+        x = (w * (plog - pminlog)) / (pmaxlog - pminlog);
+
+/*        
+        cerr << "getXForScalePoint(" << p << "): pmin = " << pmin
+             << ", pmax = " << pmax << ", w = " << w
+             << ", reqdshift = " << reqdshift
+             << ", pminlog = " << pminlog << ", pmaxlog = " << pmaxlog
+             << ", plog = " << plog 
+             << " -> x = " << x << endl;
+*/
+
+        if (m_binScale == InvertedLogBins) {
+            // still stoopid
+            x = w - x;
+        }
     }
     
     return x + origin;
 }
 

 SliceLayer::getScalePointForX(const LayerGeometryProvider *v,
                               double x, double pmin, double pmax) const
 {
     double p = 0;
 
-    double extent = pmax - pmin;
-    if (extent < 0) extent = 0;
-
     int pw = v->getPaintWidth();
     int origin = m_xorigins[v->getId()];
 
     int w = pw - origin;
     if (w < 1) w = 1;
 
     x = x - origin;
     if (x < 0) x = 0;
 
     double eps = 1e-10;
-    
-    switch (m_binScale) {
-
-    case LinearBins:
-        p = (x * extent) / w + eps;
-        break;
-        
-    case LogBins:
-        // See comment in getXForScalePoint
-        p = pow(10.0, (x * log10(extent + 0.8)) / w) - 0.8 + eps;
-        break;
-
-    case InvertedLogBins:
-        p = extent + 1 - pow(10.0, (log10(extent) * (w - x)) / double(w)) + eps;
-        break;
-    }
-
-    return p + pmin;
+
+    if (m_binScale == LinearBins) {
+        p = pmin + eps + (x * (pmax - pmin)) / w;
+    } else {
+
+        if (m_binScale == InvertedLogBins) {
+            x = w - x;
+        }
+
+        // See comments in getXForScalePoint
+
+        const double origin = 0.8;
+        double reqdshift = 0.0;
+        if (pmin < 0) reqdshift = -pmin;
+
+        double pminlog = log10(pmin + reqdshift + origin);
+        double pmaxlog = log10(pmax + reqdshift + origin);
+
+        double plog = pminlog + eps + (x * (pmaxlog - pminlog)) / w;
+        p = pow(10.0, plog) - reqdshift - origin;
+
+        if (m_binScale == InvertedLogBins) {
+            p = pmax - p;
+        }
+    }
+
+    return p;
 }
 
 double
 SliceLayer::getYForValue(const LayerGeometryProvider *v, double value, double &norm) const
 {