comparison layer/Colour3DPlotLayer.cpp @ 904:e0f08e108064 cxx11

Move to using double rather than float for floating-point calculations (float only for storage); more build fixes

     QPoint discard;
     return !v->shouldIlluminateLocalFeatures(this, discard);
 }
 
 bool
-Colour3DPlotLayer::getValueExtents(float &min, float &max,
+Colour3DPlotLayer::getValueExtents(double &min, double &max,
                                    bool &logarithmic, QString &unit) const
 {
     if (!m_model) return false;
 
     min = 0;
-    max = float(m_model->getHeight());
+    max = double(m_model->getHeight());
 
     logarithmic = false;
     unit = "";
 
     return true;
 }
 
 bool
-Colour3DPlotLayer::getDisplayExtents(float &min, float &max) const
+Colour3DPlotLayer::getDisplayExtents(double &min, double &max) const
 {
     if (!m_model) return false;
 
-    float hmax = float(m_model->getHeight());
-    
-    min = float(m_miny);
-    max = float(m_maxy);
+    double hmax = double(m_model->getHeight());
+    
+    min = m_miny;
+    max = m_maxy;
     if (max <= min) {
         min = 0;
         max = hmax;
     }
     if (min < 0) min = 0;

 
     return true;
 }
 
 bool
-Colour3DPlotLayer::setDisplayExtents(float min, float max)
+Colour3DPlotLayer::setDisplayExtents(double min, double max)
 {
     if (!m_model) return false;
 
-    m_miny = int(lrintf(min));
-    m_maxy = int(lrintf(max));
+    m_miny = int(lrint(min));
+    m_maxy = int(lrint(max));
     
     emit layerParametersChanged();
     return true;
 }
 
 bool
 Colour3DPlotLayer::getYScaleValue(const View *, int,
-                                  float &, QString &) const
+                                  double &, QString &) const
 {
     return false;//!!!
 }
 
 int

 int
 Colour3DPlotLayer::getCurrentVerticalZoomStep() const
 {
     if (!m_model) return 0;
 
-    float min, max;
+    double min, max;
     getDisplayExtents(min, max);
-    return m_model->getHeight() - int(lrintf(max - min));
+    return m_model->getHeight() - int(lrint(max - min));
 }
 
 void
 Colour3DPlotLayer::setVerticalZoomStep(int step)
 {

 
 //    SVDEBUG << "Colour3DPlotLayer::setVerticalZoomStep(" <<step <<"): before: miny = " << m_miny << ", maxy = " << m_maxy << endl;
 
     int dist = m_model->getHeight() - step;
     if (dist < 1) dist = 1;
-    float centre = float(m_miny) + (float(m_maxy) - float(m_miny)) / 2.f;
-    m_miny = int(lrintf(centre - float(dist)/2));
+    double centre = m_miny + (m_maxy - m_miny) / 2.0;
+    m_miny = int(lrint(centre - dist/2.0));
     if (m_miny < 0) m_miny = 0;
     m_maxy = m_miny + dist;
     if (m_maxy > m_model->getHeight()) m_maxy = m_model->getHeight();
 
 //    SVDEBUG << "Colour3DPlotLayer::setVerticalZoomStep(" <<step <<"):  after: miny = " << m_miny << ", maxy = " << m_maxy << endl;

 
     return new LinearRangeMapper(0, m_model->getHeight(),
                                  0, m_model->getHeight(), "");
 }
 
-float
-Colour3DPlotLayer::getYForBin(View *v, float bin) const
-{
-    float y = bin;
+double
+Colour3DPlotLayer::getYForBin(View *v, double bin) const
+{
+    double y = bin;
     if (!m_model) return y;
-    float mn = 0, mx = float(m_model->getHeight());
+    double mn = 0, mx = m_model->getHeight();
     getDisplayExtents(mn, mx);
-    float h = float(v->height());
+    double h = v->height();
     if (m_binScale == LinearBinScale) {
         y = h - (((bin - mn) * h) / (mx - mn));
     } else {
-        float logmin = mn + 1, logmax = mx + 1;
+        double logmin = mn + 1, logmax = mx + 1;
         LogRange::mapRange(logmin, logmax);
         y = h - (((LogRange::map(bin + 1) - logmin) * h) / (logmax - logmin));
     }
     return y;
 }
 
 int
 Colour3DPlotLayer::getIYForBin(View *v, int bin) const
 {
-    return int(roundf(getYForBin(v, float(bin))));
-}
-
-float
-Colour3DPlotLayer::getBinForY(View *v, float y) const
-{
-    float bin = y;
+    return int(round(getYForBin(v, bin)));
+}
+
+double
+Colour3DPlotLayer::getBinForY(View *v, double y) const
+{
+    double bin = y;
     if (!m_model) return bin;
-    float mn = 0, mx = float(m_model->getHeight());
+    double mn = 0, mx = m_model->getHeight();
     getDisplayExtents(mn, mx);
-    float h = float(v->height());
+    double h = v->height();
     if (m_binScale == LinearBinScale) {
         bin = mn + ((h - y) * (mx - mn)) / h;
     } else {
-        float logmin = mn + 1, logmax = mx + 1;
+        double logmin = mn + 1, logmax = mx + 1;
         LogRange::mapRange(logmin, logmax);
         bin = LogRange::unmap(logmin + ((h - y) * (logmax - logmin)) / h) - 1;
     }
     return bin;
 }
 
 int
 Colour3DPlotLayer::getIBinForY(View *v, int y) const
 {
-    return int(floorf(getBinForY(v, float(y))));
+    return int(floor(getBinForY(v, y)));
 }
 
 QString
 Colour3DPlotLayer::getFeatureDescription(View *v, QPoint &pos) const
 {

         symax = sh;
     }
     if (symin < 0) symin = 0;
     if (symax > sh) symax = sh;
 
- //    float binHeight = float(v->height()) / (symax - symin);
+ //    double binHeight = double(v->height()) / (symax - symin);
 //    int sy = int((v->height() - y) / binHeight) + symin;
 
     int sy = getIBinForY(v, y);
 
     if (sy < 0 || sy >= m_model->getHeight()) {

     int cw = getColourScaleWidth(paint);
     
     int ch = h - 20;
     if (ch > 20 && m_cache) {
 
-        float min = m_model->getMinimumLevel();
-        float max = m_model->getMaximumLevel();
-
-        float mmin = min;
-        float mmax = max;
+        double min = m_model->getMinimumLevel();
+        double max = m_model->getMaximumLevel();
+
+        double mmin = min;
+        double mmax = max;
 
         if (m_colourScale == LogScale) {
             LogRange::mapRange(mmin, mmax);
         } else if (m_colourScale == PlusMinusOneScale) {
             mmin = -1.f;
             mmax = 1.f;
         } else if (m_colourScale == AbsoluteScale) {
             if (mmin < 0) {
-                if (fabsf(mmin) > fabsf(mmax)) mmax = fabsf(mmin);
-                else mmax = fabsf(mmax);
+                if (fabs(mmin) > fabs(mmax)) mmax = fabs(mmin);
+                else mmax = fabs(mmax);
                 mmin = 0;
             } else {
-                mmin = fabsf(mmin);
-                mmax = fabsf(mmax);
+                mmin = fabs(mmin);
+                mmax = fabs(mmax);
             }
         }
     
         if (max == min) max = min + 1.f;
         if (mmax == mmin) mmax = mmin + 1.f;
     
         paint.setPen(v->getForeground());
         paint.drawRect(4, 10, cw - 8, ch+1);
 
         for (int y = 0; y < ch; ++y) {
-            float value = ((max - min) * (float(ch-y) - 1.f)) / float(ch) + min;
+            double value = ((max - min) * (double(ch-y) - 1.0)) / double(ch) + min;
             if (m_colourScale == LogScale) {
                 value = LogRange::map(value);
             }
             int pixel = int(((value - mmin) * 256) / (mmax - mmin));
             if (pixel >= 0 && pixel < 256) {

 
     DenseThreeDimensionalModel::Column values = m_model->getColumn(col);
     while (values.size() < m_model->getHeight()) values.push_back(0.f);
     if (!m_normalizeColumns && !m_normalizeHybrid) return values;
 
-    float colMax = 0.f, colMin = 0.f;
-    float min = 0.f, max = 0.f;
+    double colMax = 0.f, colMin = 0.f;
+    double min = 0.f, max = 0.f;
 
     min = m_model->getMinimumLevel();
     max = m_model->getMaximumLevel();
 
     for (int y = 0; y < values.size(); ++y) {

     }
     if (colMin == colMax) colMax = colMin + 1;
     
     for (int y = 0; y < values.size(); ++y) {
     
-        float value = values.at(y);
-        float norm = (value - colMin) / (colMax - colMin);
-        float newvalue = min + (max - min) * norm;
-
-        if (value != newvalue) values[y] = newvalue;
+        double value = values.at(y);
+        double norm = (value - colMin) / (colMax - colMin);
+        double newvalue = min + (max - min) * norm;
+
+        if (value != newvalue) values[y] = float(newvalue);
     }
 
     if (m_normalizeHybrid && (colMax > 0.0)) {
-        float logmax = log10f(colMax);
+        double logmax = log10(colMax);
         for (int y = 0; y < values.size(); ++y) {
-            values[y] *= logmax;
+            values[y] = float(values[y] * logmax);
         }
     }
 
     return values;
 }

     cerr << "Cache size " << cacheWidth << "x" << cacheHeight << " will be valid from " << m_cacheValidStart << " to " << m_cacheValidEnd << " (fillStart = " << fillStart << ", fillEnd = " << fillEnd << ")" << endl;
 #endif
 
     DenseThreeDimensionalModel::Column values;
 
-    float min = m_model->getMinimumLevel();
-    float max = m_model->getMaximumLevel();
+    double min = m_model->getMinimumLevel();
+    double max = m_model->getMaximumLevel();
 
     if (m_colourScale == LogScale) {
         LogRange::mapRange(min, max);
     } else if (m_colourScale == PlusMinusOneScale) {
         min = -1.f;
         max = 1.f;
     } else if (m_colourScale == AbsoluteScale) {
         if (min < 0) {
-            if (fabsf(min) > fabsf(max)) max = fabsf(min);
-            else max = fabsf(max);
+            if (fabs(min) > fabs(max)) max = fabs(min);
+            else max = fabs(max);
             min = 0;
         } else {
-            min = fabsf(min);
-            max = fabsf(max);
+            min = fabs(min);
+            max = fabs(max);
         }
     }
     
     if (max == min) max = min + 1.f;
     

             m_peaksCache->setColor
                 (index, qRgb(colour.red(), colour.green(), colour.blue()));
         }
     }
     
-    float visibleMax = 0.f, visibleMin = 0.f;
+    double visibleMax = 0.f, visibleMin = 0.f;
 
     if (normalizeVisible) {
         
         for (int c = fillStart; c <= fillEnd; ++c) {
 	
             values = getColumn(c);
 
-            float colMax = 0.f, colMin = 0.f;
+            double colMax = 0.f, colMin = 0.f;
 
             for (int y = 0; y < cacheHeight; ++y) {
                 if (y >= values.size()) break;
                 if (y == 0 || values[y] > colMax) colMax = values[y];
                 if (y == 0 || values[y] < colMin) colMin = values[y];

             visibleMin = LogRange::map(visibleMin);
             visibleMax = LogRange::map(visibleMax);
             if (visibleMin > visibleMax) std::swap(visibleMin, visibleMax);
         } else if (m_colourScale == AbsoluteScale) {
             if (visibleMin < 0) {
-                if (fabsf(visibleMin) > fabsf(visibleMax)) visibleMax = fabsf(visibleMin);
-                else visibleMax = fabsf(visibleMax);
+                if (fabs(visibleMin) > fabs(visibleMax)) visibleMax = fabs(visibleMin);
+                else visibleMax = fabs(visibleMax);
                 visibleMin = 0;
             } else {
-                visibleMin = fabsf(visibleMin);
-                visibleMax = fabsf(visibleMax);
+                visibleMin = fabs(visibleMin);
+                visibleMax = fabs(visibleMax);
             }
         }
     }
     
     if (visibleMin == visibleMax) visibleMax = visibleMin + 1;

             continue;
         }
 
         for (int y = 0; y < cacheHeight; ++y) {
 
-            float value = min;
+            double value = min;
             if (y < values.size()) {
                 value = values.at(y);
             }
 
             value = value * m_gain;
 
             if (m_colourScale == LogScale) {
                 value = LogRange::map(value);
             } else if (m_colourScale == AbsoluteScale) {
-                value = fabsf(value);
+                value = fabs(value);
             }
             
             if (normalizeVisible) {
-                float norm = (value - visibleMin) / (visibleMax - visibleMin);
+                double norm = (value - visibleMin) / (visibleMax - visibleMin);
                 value = min + (max - min) * norm;
             }
 
             int pixel = int(((value - min) * 256) / (max - min));
             if (pixel < 0) pixel = 0;

 	    paint.drawRect(r);
 
 	    if (showLabel) {
 		if (sx >= 0 && sx < m_cache->width() &&
 		    sy >= 0 && sy < m_cache->height()) {
-		    float value = m_model->getValueAt(sx, sy);
+		    double value = m_model->getValueAt(sx, sy);
 		    snprintf(labelbuf, buflen, "%06f", value);
 		    QString text(labelbuf);
 		    paint.setPen(v->getBackground());
 		    paint.drawText(rx0 + 2,
 				   ry0 - h / sh - 1 + 2 + paint.fontMetrics().ascent(),

 
         sxa[x*2] = sx0;
         sxa[x*2 + 1] = sx1;
     }
 
-    float logmin = float(symin+1), logmax = float(symax+1);
+    double logmin = symin+1, logmax = symax+1;
     LogRange::mapRange(logmin, logmax);
 
 #ifdef DEBUG_COLOUR_3D_PLOT_LAYER_PAINT
     cerr << "m_smooth = " << m_smooth << ", w = " << w << ", h = " << h << endl;
 #endif
 
     if (m_smooth) {
         
         for (int y = 0; y < h; ++y) {
 
-            double sy = getBinForY(v, float(y)) - 0.5;
+            double sy = getBinForY(v, y) - 0.5;
             int syi = int(sy + epsilon);
             if (syi < 0 || syi >= source->height()) continue;
 
             uchar *targetLine = img.scanLine(y);
             uchar *sourceLine = source->scanLine(syi);

                 targetLine[x] = uchar(vi);
             }
         }
     } else {
 
-        float sy0 = getBinForY(v, 0);
+        double sy0 = getBinForY(v, 0);
 
         int psy0i = -1, psy1i = -1;
 
         for (int y = 0; y < h; ++y) {
 
-            float sy1 = sy0;
-            sy0 = getBinForY(v, float(y + 1));
+            double sy1 = sy0;
+            sy0 = getBinForY(v, double(y + 1));
 
             int sy0i = int(sy0 + epsilon);
             int sy1i = int(sy1);
 
             uchar *targetLine = img.scanLine(y);

 
     paint.drawImage(x0, 0, img);
 }
 
 bool
-Colour3DPlotLayer::snapToFeatureFrame(View *v, int &frame,
+Colour3DPlotLayer::snapToFeatureFrame(View *v, sv_frame_t &frame,
 				      int &resolution,
 				      SnapType snap) const
 {
     if (!m_model) {
 	return Layer::snapToFeatureFrame(v, frame, resolution, snap);
     }
 
     resolution = m_model->getResolution();
-    int left = (frame / resolution) * resolution;
-    int right = left + resolution;
+    sv_frame_t left = (frame / resolution) * resolution;
+    sv_frame_t right = left + resolution;
 
     switch (snap) {
     case SnapLeft:  frame = left;  break;
     case SnapRight: frame = right; break;
     case SnapNearest: