comparison layer/Colour3DPlotLayer.cpp @ 474:efc2bd6d3611

* take a bit more care about peaks cache sizing

 
 Colour3DPlotLayer::Colour3DPlotLayer() :
     m_model(0),
     m_cache(0),
     m_peaksCache(0),
-    m_peakResolution(128),
+    m_peakResolution(256),
     m_cacheValidStart(0),
     m_cacheValidEnd(0),
     m_colourScale(LinearScale),
     m_colourScaleSet(false),
     m_colourMap(0),

     connectSignals(m_model);
 
     connect(m_model, SIGNAL(modelChanged()), this, SLOT(modelChanged()));
     connect(m_model, SIGNAL(modelChanged(size_t, size_t)),
 	    this, SLOT(modelChanged(size_t, size_t)));
+
+    m_peakResolution = 256;
+    if (model->getResolution() > 512) {
+        m_peakResolution = 16;
+    } else if (model->getResolution() > 128) {
+        m_peakResolution = 64;
+    } else if (model->getResolution() > 2) {
+        m_peakResolution = 128;
+    }
+    cacheInvalid();
 
     emit modelReplaced();
     emit sliceableModelReplaced(oldModel, model);
 }
 

 
     if (!m_cache) {
         m_cache = new QImage
             (cacheWidth, cacheHeight, QImage::Format_Indexed8);
         m_cache->setNumColors(256);
-        if (modelResolution < m_peakResolution / 2 && !m_normalizeVisibleArea) {
+        if (!m_normalizeVisibleArea) {
             m_peaksCache = new QImage
                 (cacheWidth / m_peakResolution + 1, cacheHeight,
                  QImage::Format_Indexed8);
             m_peaksCache->setNumColors(256);
         } else if (m_peaksCache) {

     memset(peaks, 0, w);
 
     int zoomLevel = v->getZoomLevel();
     
     QImage *source = m_cache;
-    if (m_peaksCache &&
-        ((modelResolution * srRatio * m_peakResolution) / zoomLevel) < 1) {
-//        std::cerr << "using peaks cache" << std::endl;
-        source = m_peaksCache;
-        modelResolution *= m_peakResolution;
+    
+    std::cerr << "modelResolution " << modelResolution << ", srRatio "
+              << srRatio << ", m_peakResolution " << m_peakResolution
+              << ", zoomLevel " << zoomLevel << ", result "
+              << ((modelResolution * srRatio * m_peakResolution) / zoomLevel)
+              << std::endl;
+
+    if (m_peaksCache) {
+        if (((modelResolution * srRatio * m_peakResolution) / zoomLevel) < 1) {
+            std::cerr << "using peaks cache" << std::endl;
+            source = m_peaksCache;
+            modelResolution *= m_peakResolution;
+        } else {
+            std::cerr << "not using peaks cache" << std::endl;
+        }
     } else {
-//        std::cerr << "not using peaks cache" << std::endl;
+        std::cerr << "have no peaks cache" << std::endl;
     }
 
     int psy1i = -1;
     int sw = source->width();
     

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