comparison layer/Colour3DPlotLayer.cpp @ 946:36cddc3de023 alignment_view

Merge from default branch

 #include <cassert>
 
 #ifndef __GNUC__
 #include <alloca.h>
 #endif
+
+using std::vector;
 
 //#define DEBUG_COLOUR_3D_PLOT_LAYER_PAINT 1
 
 
 Colour3DPlotLayer::Colour3DPlotLayer() :

     if (!m_model || !m_model->isOK()) return;
 
     connectSignals(m_model);
 
     connect(m_model, SIGNAL(modelChanged()), this, SLOT(modelChanged()));
-    connect(m_model, SIGNAL(modelChangedWithin(int, int)),
-	    this, SLOT(modelChangedWithin(int, int)));
+    connect(m_model, SIGNAL(modelChangedWithin(sv_frame_t, sv_frame_t)),
+	    this, SLOT(modelChangedWithin(sv_frame_t, sv_frame_t)));
 
     m_peakResolution = 256;
     if (model->getResolution() > 512) {
         m_peakResolution = 16;
     } else if (model->getResolution() > 128) {

     m_cacheValidStart = 0;
     m_cacheValidEnd = 0;
 }
 
 void
-Colour3DPlotLayer::cacheInvalid(int startFrame, int endFrame)
+Colour3DPlotLayer::cacheInvalid(sv_frame_t startFrame, sv_frame_t endFrame)
 {
     if (!m_cache || !m_model) return;
 
     int modelResolution = m_model->getResolution();
-    int start = startFrame / modelResolution;
-    int end = endFrame / modelResolution + 1;
+    int start = int(startFrame / modelResolution);
+    int end = int(endFrame / modelResolution + 1);
     if (m_cacheValidStart < end) m_cacheValidStart = end;
     if (m_cacheValidEnd > start) m_cacheValidEnd = start;
     if (m_cacheValidStart > m_cacheValidEnd) m_cacheValidEnd = m_cacheValidStart;
 }
 

     }
     cacheInvalid();
 }
 
 void
-Colour3DPlotLayer::modelChangedWithin(int startFrame, int endFrame)
+Colour3DPlotLayer::modelChangedWithin(sv_frame_t startFrame, sv_frame_t endFrame)
 {
     if (!m_colourScaleSet && m_colourScale == LinearScale) {
         if (m_model && m_model->getWidth() > 50) {
             if (m_model->shouldUseLogValueScale()) {
                 setColourScale(LogScale);

     if (name == "Gain") {
 
 	*min = -50;
 	*max = 50;
 
-        *deflt = lrintf(log10(1.f) * 20.0);;
+        *deflt = int(lrint(log10(1.0) * 20.0));
 	if (*deflt < *min) *deflt = *min;
 	if (*deflt > *max) *deflt = *max;
 
-	val = lrintf(log10(m_gain) * 20.0);
+	val = int(lrint(log10(m_gain) * 20.0));
 	if (val < *min) val = *min;
 	if (val > *max) val = *max;
 
     } else if (name == "Colour Scale") {
 

 
 void
 Colour3DPlotLayer::setProperty(const PropertyName &name, int value)
 {
     if (name == "Gain") {
-	setGain(pow(10, float(value)/20.0));
+	setGain(float(pow(10, value/20.0)));
     } else if (name == "Colour Scale") {
 	switch (value) {
 	default:
 	case 0: setColourScale(LinearScale); break;
 	case 1: setColourScale(LogScale); break;

     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 = 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;
 
+    double hmax = double(m_model->getHeight());
+    
     min = m_miny;
     max = m_maxy;
     if (max <= min) {
         min = 0;
-        max = m_model->getHeight();
+        max = hmax;
     }
     if (min < 0) min = 0;
-    if (max > m_model->getHeight()) max = m_model->getHeight();
+    if (max > hmax) max = hmax;
 
     return true;
 }
 
 bool
-Colour3DPlotLayer::setDisplayExtents(float min, float max)
+Colour3DPlotLayer::setDisplayExtents(double min, double max)
 {
     if (!m_model) return false;
 
-    m_miny = lrintf(min);
-    m_maxy = 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() - 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 = m_miny + (float(m_maxy) - float(m_miny)) / 2.f;
-    m_miny = 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 = m_model->getHeight();
+    double mn = 0, mx = m_model->getHeight();
     getDisplayExtents(mn, mx);
-    float h = 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;
 }
 
-float
-Colour3DPlotLayer::getBinForY(View *v, float y) const
-{
-    float bin = y;
+int
+Colour3DPlotLayer::getIYForBin(View *v, int bin) const
+{
+    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 = m_model->getHeight();
+    double mn = 0, mx = m_model->getHeight();
     getDisplayExtents(mn, mx);
-    float h = 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(floor(getBinForY(v, y)));
+}
+
 QString
 Colour3DPlotLayer::getFeatureDescription(View *v, QPoint &pos) const
 {
     if (!m_model) return "";
 
     int x = pos.x();
     int y = pos.y();
 
-    int modelStart = m_model->getStartFrame();
+    sv_frame_t modelStart = m_model->getStartFrame();
     int modelResolution = m_model->getResolution();
 
-    float srRatio =
-        float(v->getViewManager()->getMainModelSampleRate()) /
-        float(m_model->getSampleRate());
-
-    int sx0 = int((v->getFrameForX(x) / srRatio - modelStart) /
+    double srRatio =
+        v->getViewManager()->getMainModelSampleRate() /
+        m_model->getSampleRate();
+
+    int sx0 = int((double(v->getFrameForX(x)) / srRatio - double(modelStart)) /
                   modelResolution);
 
     int f0 = sx0 * modelResolution;
     int f1 =  f0 + modelResolution;
 

         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 = getBinForY(v, y);
+    int sy = getIBinForY(v, y);
 
     if (sy < 0 || sy >= m_model->getHeight()) {
         return "";
     }
 

     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);
-            }
-        }
-    
-        if (max == min) max = min + 1.0;
-        if (mmax == mmin) mmax = mmin + 1.0;
+                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) * (ch - y - 1)) / 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) {

 
     for (int i = symin; i <= symax; ++i) {
 
         int y0;
 
-        y0 = lrintf(getYForBin(v, i));
+        y0 = getIYForBin(v, i);
         int h = py - y0;
 
         if (i > symin) {
             if (paint.fontMetrics().height() >= h) {
                 if (h >= 8) {

 
     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 = log10(colMax);
+        double logmax = log10(colMax);
         for (int y = 0; y < values.size(); ++y) {
-            values[y] *= logmax;
+            values[y] = float(values[y] * logmax);
         }
     }
 
     return values;
 }

 void
 Colour3DPlotLayer::fillCache(int firstBin, int lastBin) const
 {
     Profiler profiler("Colour3DPlotLayer::fillCache", true);
 
-    int modelStart = m_model->getStartFrame();
-    int modelEnd = m_model->getEndFrame();
+    sv_frame_t modelStart = m_model->getStartFrame();
+    sv_frame_t modelEnd = m_model->getEndFrame();
     int modelResolution = m_model->getResolution();
 
-    int modelStartBin = modelStart / modelResolution;
-    int modelEndBin = modelEnd / modelResolution;
+    int modelStartBin = int(modelStart / modelResolution);
+    int modelEndBin = int(modelEnd / modelResolution);
 
 #ifdef DEBUG_COLOUR_3D_PLOT_LAYER_PAINT
     cerr << "Colour3DPlotLayer::fillCache: range " << firstBin << " -> " << lastBin << " of model range " << modelStartBin << " -> " << modelEndBin << " (model resolution " << modelResolution << ")" << endl;
 #endif
 

     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);
-        }
-    }
-    
-    if (max == min) max = min + 1.0;
+            min = fabs(min);
+            max = fabs(max);
+        }
+    }
+    
+    if (max == min) max = min + 1.f;
     
     ColourMapper mapper(m_colourMap, 0.f, 255.f);
     
     for (int index = 0; index < 256; ++index) {
         QColor colour = mapper.map(index);

             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;

 Colour3DPlotLayer::shouldPaintDenseIn(const View *v) const
 {
     if (!m_model || !v || !(v->getViewManager())) {
         return false;
     }
-    float srRatio =
-        float(v->getViewManager()->getMainModelSampleRate()) /
-        float(m_model->getSampleRate());
+    double srRatio =
+        v->getViewManager()->getMainModelSampleRate() / m_model->getSampleRate();
     if (m_opaque || 
         m_smooth ||
         m_model->getHeight() >= v->height() ||
         ((m_model->getResolution() * srRatio) / v->getZoomLevel()) < 2) {
         return true;

 	return;
     }
 
     if (m_normalizeVisibleArea && !m_normalizeColumns) rect = v->rect();
 
-    int modelStart = m_model->getStartFrame();
-    int modelEnd = m_model->getEndFrame();
+    sv_frame_t modelStart = m_model->getStartFrame();
+    sv_frame_t modelEnd = m_model->getEndFrame();
     int modelResolution = m_model->getResolution();
 
     // The cache is from the model's start frame to the model's end
     // frame at the model's window increment frames per pixel.  We
     // want to draw from our start frame + x0 * zoomLevel to our start

     int x0 = rect.left();
     int x1 = rect.right() + 1;
 
     int h = v->height();
 
-    float srRatio =
-        float(v->getViewManager()->getMainModelSampleRate()) /
-        float(m_model->getSampleRate());
-
-    int sx0 = int((v->getFrameForX(x0) / srRatio - modelStart)
+    double srRatio =
+        v->getViewManager()->getMainModelSampleRate() / m_model->getSampleRate();
+
+    int sx0 = int((double(v->getFrameForX(x0)) / srRatio - double(modelStart))
                   / modelResolution);
-    int sx1 = int((v->getFrameForX(x1) / srRatio - modelStart)
+    int sx1 = int((double(v->getFrameForX(x1)) / srRatio - double(modelStart))
                   / modelResolution);
     int sh = m_model->getHeight();
 
     int symin = m_miny;
     int symax = m_maxy;

     const int buflen = 40;
     char labelbuf[buflen];
 
     for (int sx = sx0; sx <= sx1; ++sx) {
 
-	int fx = sx * modelResolution;
+	sv_frame_t fx = sx * modelResolution;
 
 	if (fx + modelResolution <= modelStart || fx > modelEnd) continue;
 
-        int rx0 = v->getXForFrame(int((fx + modelStart) * srRatio));
-	int rx1 = v->getXForFrame(int((fx + modelStart + modelResolution + 1) * srRatio));
+        int rx0 = v->getXForFrame(int(double(fx + modelStart) * srRatio));
+	int rx1 = v->getXForFrame(int(double(fx + modelStart + modelResolution + 1) * srRatio));
 
 	int rw = rx1 - rx0;
 	if (rw < 1) rw = 1;
 
 	bool showLabel = (rw > 10 &&
 			  paint.fontMetrics().width("0.000000") < rw - 3 &&
 			  paint.fontMetrics().height() < (h / sh));
         
 	for (int sy = symin; sy < symax; ++sy) {
 
-            int ry0 = getYForBin(v, sy);
-            int ry1 = getYForBin(v, sy + 1);
+            int ry0 = getIYForBin(v, sy);
+            int ry1 = getIYForBin(v, sy + 1);
             QRect r(rx0, ry1, rw, ry0 - ry1);
 
 	    QRgb pixel = qRgb(255, 255, 255);
 	    if (sx >= 0 && sx < m_cache->width() &&
 		sy >= 0 && sy < m_cache->height()) {

 	    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(),

 Colour3DPlotLayer::paintDense(View *v, QPainter &paint, QRect rect) const
 {
     Profiler profiler("Colour3DPlotLayer::paintDense", true);
     if (!m_cache) return;
 
-    float modelStart = m_model->getStartFrame();
-    float modelResolution = m_model->getResolution();
-
-    int mmsr = v->getViewManager()->getMainModelSampleRate();
-    int msr = m_model->getSampleRate();
-    float srRatio = float(mmsr) / float(msr);
+    double modelStart = double(m_model->getStartFrame());
+    double modelResolution = double(m_model->getResolution());
+
+    sv_samplerate_t mmsr = v->getViewManager()->getMainModelSampleRate();
+    sv_samplerate_t msr = m_model->getSampleRate();
+    double srRatio = mmsr / msr;
 
     int x0 = rect.left();
     int x1 = rect.right() + 1;
 
     const int w = x1 - x0; // const so it can be used as array size below

 #endif
     }
 
     int sw = source->width();
     
-    int xf = -1;
-    int nxf = v->getFrameForX(x0);
-
-    float epsilon = 0.000001;
-
-#ifdef __GNUC__
-    float sxa[w * 2];
-#else
-    float *sxa = (float *)alloca(w * 2 * sizeof(float));
-#endif
+    sv_frame_t xf = -1;
+    sv_frame_t nxf = v->getFrameForX(x0);
+
+    double epsilon = 0.000001;
+
+    vector<double> sxa(w*2);
+    
     for (int x = 0; x < w; ++x) {
 
         xf = nxf;
         nxf = xf + zoomLevel;
 
-        float sx0 = (float(xf) / srRatio - modelStart) / modelResolution;
-        float sx1 = (float(nxf) / srRatio - modelStart) / modelResolution;
+        double sx0 = (double(xf) / srRatio - modelStart) / modelResolution;
+        double sx1 = (double(nxf) / srRatio - modelStart) / modelResolution;
 
         sxa[x*2] = sx0;
         sxa[x*2 + 1] = sx1;
     }
 
-    float logmin = symin+1, logmax = 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) {
 
-            float sy = getBinForY(v, 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);

 
             for (int x = 0; x < w; ++x) {
 
                 targetLine[x] = 0;
 
-                float sx0 = sxa[x*2];
+                double sx0 = sxa[x*2];
                 if (sx0 < 0) continue;
                 int sx0i = int(sx0 + epsilon);
                 if (sx0i >= sw) break;
 
-                float a = float(sourceLine[sx0i]);
-                float b = a;
-                float value;
-
-                float sx1 = sxa[x*2+1];
+                double a = sourceLine[sx0i];
+                double b = a;
+                double value;
+
+                double sx1 = sxa[x*2+1];
                 if (sx1 > sx0 + 1.f) {
                     int sx1i = int(sx1);
                     bool have = false;
                     for (int sx = sx0i; sx <= sx1i; ++sx) {
                         if (sx < 0 || sx >= sw) continue;
                         if (!have) {
-                            a = float(sourceLine[sx]);
-                            b = float(nextSource[sx]);
+                            a = sourceLine[sx];
+                            b = nextSource[sx];
                             have = true;
                         } else {
-                            a = std::max(a, float(sourceLine[sx]));
-                            b = std::max(b, float(nextSource[sx]));
+                            a = std::max(a, double(sourceLine[sx]));
+                            b = std::max(b, double(nextSource[sx]));
                         }
                     }
-                    float yprop = sy - syi;
+                    double yprop = sy - syi;
                     value = (a * (1.f - yprop) + b * yprop);
                 } else {
-                    a = float(sourceLine[sx0i]);
-                    b = float(nextSource[sx0i]);
-                    float yprop = sy - syi;
+                    a = sourceLine[sx0i];
+                    b = nextSource[sx0i];
+                    double yprop = sy - syi;
                     value = (a * (1.f - yprop) + b * yprop);
                     int oi = sx0i + 1;
-                    float xprop = sx0 - sx0i;
+                    double xprop = sx0 - sx0i;
                     xprop -= 0.5;
                     if (xprop < 0) {
                         oi = sx0i - 1;
                         xprop = -xprop;
                     }
                     if (oi < 0 || oi >= sw) oi = sx0i;
-                    a = float(sourceLine[oi]);
-                    b = float(nextSource[oi]);
+                    a = sourceLine[oi];
+                    b = nextSource[oi];
                     value = (value * (1.f - xprop) +
                              (a * (1.f - yprop) + b * yprop) * xprop);
                 }
                 
-                int vi = lrintf(value);
+                int vi = int(lrint(value));
                 if (vi > 255) vi = 255;
                 if (vi < 0) vi = 0;
                 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, 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);

 
                 uchar *sourceLine = source->scanLine(sy);
             
                 for (int x = 0; x < w; ++x) {
 
-                    float sx1 = sxa[x*2 + 1];
+                    double sx1 = sxa[x*2 + 1];
                     if (sx1 < 0) continue;
                     int sx1i = int(sx1);
 
-                    float sx0 = sxa[x*2];
+                    double sx0 = sxa[x*2];
                     if (sx0 < 0) continue;
                     int sx0i = int(sx0 + epsilon);
                     if (sx0i >= sw) break;
 
                     uchar peak = 0;

 
     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: