comparison layer/Colour3DPlotLayer.cpp @ 461:272e58f0bf8b sv-v1.4 sv-v1.4rc1

* Knock a bit of sense into Colour3DPlotLayer's cache management

 
 
 Colour3DPlotLayer::Colour3DPlotLayer() :
     m_model(0),
     m_cache(0),
-    m_cacheStart(0),
+    m_cacheValidStart(0),
+    m_cacheValidEnd(0),
     m_colourScale(LinearScale),
+    m_colourScaleSet(false),
     m_colourMap(0),
     m_normalizeColumns(false),
     m_normalizeVisibleArea(false),
     m_invertVertical(false),
     m_miny(0),

     
 }
 
 Colour3DPlotLayer::~Colour3DPlotLayer()
 {
+    delete m_cache;
 }
 
 void
 Colour3DPlotLayer::setModel(const DenseThreeDimensionalModel *model)
 {

     m_model = model;
     if (!m_model || !m_model->isOK()) return;
 
     connectSignals(m_model);
 
-    connect(m_model, SIGNAL(modelChanged()), this, SLOT(cacheInvalid()));
+    connect(m_model, SIGNAL(modelChanged()), this, SLOT(modelChanged()));
     connect(m_model, SIGNAL(modelChanged(size_t, size_t)),
-	    this, SLOT(cacheInvalid(size_t, size_t)));
+	    this, SLOT(modelChanged(size_t, size_t)));
 
     emit modelReplaced();
     emit sliceableModelReplaced(oldModel, model);
 }
 
 void
 Colour3DPlotLayer::cacheInvalid()
 {
     delete m_cache; 
     m_cache = 0;
-}
-
-void
-Colour3DPlotLayer::cacheInvalid(size_t, size_t)
-{
+    m_cacheValidStart = 0;
+    m_cacheValidEnd = 0;
+}
+
+void
+Colour3DPlotLayer::cacheInvalid(size_t startFrame, size_t endFrame)
+{
+    if (!m_cache) return;
+
+    size_t modelResolution = m_model->getResolution();
+    size_t start = startFrame / modelResolution;
+    size_t end = 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;
+}
+
+void
+Colour3DPlotLayer::modelChanged()
+{
+    if (!m_colourScaleSet && m_colourScale == LinearScale) {
+        if (m_model) {
+            if (m_model->shouldUseLogValueScale()) {
+                setColourScale(LogScale);
+            } else {
+                m_colourScaleSet = true;
+            }
+        }
+    }
     cacheInvalid();
+}
+
+void
+Colour3DPlotLayer::modelChanged(size_t startFrame, size_t endFrame)
+{
+    if (!m_colourScaleSet && m_colourScale == LinearScale) {
+        if (m_model && m_model->getWidth() > 50) {
+            if (m_model->shouldUseLogValueScale()) {
+                setColourScale(LogScale);
+            } else {
+                m_colourScaleSet = true;
+            }
+        }
+    }
+    cacheInvalid(startFrame, endFrame);
 }
 
 Layer::PropertyList
 Colour3DPlotLayer::getProperties() const
 {

 void
 Colour3DPlotLayer::setColourScale(ColourScale scale)
 {
     if (m_colourScale == scale) return;
     m_colourScale = scale;
+    m_colourScaleSet = true;
     cacheInvalid();
     emit layerParametersChanged();
 }
 
 void

 Colour3DPlotLayer::getColumn(size_t col,
                              DenseThreeDimensionalModel::Column &values) const
 {
     m_model->getColumn(col, values);
 
+    if (!m_normalizeColumns) return;
+
     float colMax = 0.f, colMin = 0.f;
-
     float min = 0.f, max = 0.f;
-    if (m_normalizeColumns) {
-        min = m_model->getMinimumLevel();
-        max = m_model->getMaximumLevel();
-    }
-
-    if (m_normalizeColumns) {
-        for (size_t y = 0; y < values.size(); ++y) {
-            if (y == 0 || values[y] > colMax) colMax = values[y];
-            if (y == 0 || values[y] < colMin) colMin = values[y];
-        }
-        if (colMin == colMax) colMax = colMin + 1;
-    }
-    
+
+    min = m_model->getMinimumLevel();
+    max = m_model->getMaximumLevel();
+
     for (size_t y = 0; y < values.size(); ++y) {
-        
-        float value = min;
-
-        value = values[y];
-
-        if (m_normalizeColumns) {
-            float norm = (value - colMin) / (colMax - colMin);
-            value = min + (max - min) * norm;
-        }
+        if (y == 0 || values[y] > colMax) colMax = values[y];
+        if (y == 0 || values[y] < colMin) colMin = values[y];
+    }
+    if (colMin == colMax) colMax = colMin + 1;
+    
+    for (size_t y = 0; y < values.size(); ++y) {
+    
+        float value = values[y];
+        float norm = (value - colMin) / (colMax - colMin);
+        value = min + (max - min) * norm;
 
         values[y] = value;
     }    
 }
     

     size_t modelEnd = m_model->getEndFrame();
     size_t modelResolution = m_model->getResolution();
 
 //    std::cerr << "Colour3DPlotLayer::fillCache: " << firstBin << " -> " << lastBin << std::endl;
 
-    if (!m_normalizeVisibleArea || m_normalizeColumns) {
-        firstBin = modelStart / modelResolution;
-        lastBin = modelEnd / modelResolution;
-    }
-
-    size_t cacheWidth = lastBin - firstBin + 1;
+    size_t modelStartBin = modelStart / modelResolution;
+    size_t modelEndBin = modelEnd / modelResolution;
+
+    size_t cacheWidth = modelEndBin - modelStartBin + 1;
     size_t cacheHeight = m_model->getHeight();
 
-    if (m_cache &&
-	(m_cacheStart != firstBin ||
-         m_cache->width() != int(cacheWidth) ||
-	 m_cache->height() != int(cacheHeight))) {
-
-	delete m_cache;
-	m_cache = 0;
-    }
-
-    if (m_cache) return;
-
-    m_cache = new QImage(cacheWidth, cacheHeight, QImage::Format_Indexed8);
-    m_cacheStart = firstBin;
-
-//    std::cerr << "Cache size " << cacheWidth << "x" << cacheHeight << " starting " << m_cacheStart << std::endl;
-
-    m_cache->setNumColors(256);
+    if (m_cache && (m_cache->height() != int(cacheHeight))) {
+        delete m_cache;
+        m_cache = 0;
+    } 
+
+    if (m_cache && (m_cache->width() != int(cacheWidth))) {
+        QImage *newCache = new QImage(m_cache->copy(0, 0, cacheWidth, cacheHeight));
+        delete m_cache;
+        m_cache = newCache;
+    }
+
+    if (!m_cache) {
+        m_cache = new QImage(cacheWidth, cacheHeight, QImage::Format_Indexed8);
+        m_cache->setNumColors(256);
+        m_cacheValidStart = 0;
+        m_cacheValidEnd = 0;
+    }
+
+    if (m_cacheValidStart <= firstBin && m_cacheValidEnd >= lastBin) {
+        return;
+    }
+    
+    size_t fillStart = firstBin;
+    size_t fillEnd = lastBin;
+
+    if (fillStart < modelStartBin) fillStart = modelStartBin;
+    if (fillStart > modelEndBin) fillStart = modelEndBin;
+    if (fillEnd < modelStartBin) fillEnd = modelStartBin;
+    if (fillEnd > modelEndBin) fillEnd = modelEndBin;
+
+    bool normalizeVisible = (m_normalizeVisibleArea && !m_normalizeColumns);
+
+    if (!normalizeVisible && (m_cacheValidStart < m_cacheValidEnd)) {
+        
+        if (m_cacheValidEnd < fillStart) {
+            fillStart = m_cacheValidEnd + 1;
+        }
+        if (m_cacheValidStart > fillEnd) {
+            fillEnd = m_cacheValidStart - 1;
+        }
+        
+        m_cacheValidStart = std::min(fillStart, m_cacheValidStart);
+        m_cacheValidEnd = std::max(fillEnd, m_cacheValidEnd);
+
+    } else {
+
+        // the only valid area, ever, is the currently visible one
+
+        m_cacheValidStart = fillStart;
+        m_cacheValidEnd = fillEnd;
+    }
+
+//    std::cerr << "Cache size " << cacheWidth << "x" << cacheHeight << " will be valid from " << m_cacheValidStart << " to " << m_cacheValidEnd << std::endl;
+
     DenseThreeDimensionalModel::Column values;
+    values.reserve(cacheHeight);
 
     float min = m_model->getMinimumLevel();
     float max = m_model->getMaximumLevel();
 
     if (m_colourScale == LogScale) {

     if (max == min) max = min + 1.0;
     
     ColourMapper mapper(m_colourMap, 0.f, 255.f);
     
     for (int index = 0; index < 256; ++index) {
-        
         QColor colour = mapper.map(index);
         m_cache->setColor(index, qRgb(colour.red(), colour.green(), colour.blue()));
     }
     
-    m_cache->fill(0);
+//    m_cache->fill(0);
 
     float visibleMax = 0.f, visibleMin = 0.f;
 
-    if (m_normalizeVisibleArea && !m_normalizeColumns) {
+    if (normalizeVisible) {
         
-        for (size_t c = firstBin; c <= lastBin; ++c) {
+        for (size_t c = fillStart; c <= fillEnd; ++c) {
 	
             values.clear();
             getColumn(c, values);
 
             float colMax = 0.f, colMin = 0.f;
 
-            for (size_t y = 0; y < m_model->getHeight(); ++y) {
+            for (size_t 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];
             }
 
-            if (c == firstBin || colMax > visibleMax) visibleMax = colMax;
-            if (c == firstBin || colMin < visibleMin) visibleMin = colMin;
+            if (c == fillStart || colMax > visibleMax) visibleMax = colMax;
+            if (c == fillStart || colMin < visibleMin) visibleMin = colMin;
         }
+
+        if (m_colourScale == LogScale) {
+            visibleMin = LogRange::map(visibleMin);
+            visibleMax = LogRange::map(visibleMax);
+            if (visibleMin > visibleMax) std::swap(visibleMin, visibleMax);
+        }
     }
     
     if (visibleMin == visibleMax) visibleMax = visibleMin + 1;
 
-    for (size_t c = firstBin; c <= lastBin; ++c) {
+    for (size_t c = fillStart; c <= fillEnd; ++c) {
 	
         values.clear();
         getColumn(c, values);
 
-        for (size_t y = 0; y < m_model->getHeight(); ++y) {
+        for (size_t y = 0; y < cacheHeight; ++y) {
 
             float value = min;
             if (y < values.size()) {
                 value = values[y];
             }
+
+            if (m_colourScale == LogScale) {
+                value = LogRange::map(value);
+            }
             
-            if (m_normalizeVisibleArea && !m_normalizeColumns) {
+            if (normalizeVisible) {
                 float norm = (value - visibleMin) / (visibleMax - visibleMin);
                 value = min + (max - min) * norm;
             }
 
-            if (m_colourScale == LogScale) {
-                value = LogRange::map(value);
-            }
-
             int pixel = int(((value - min) * 256) / (max - min));
             if (pixel < 0) pixel = 0;
             if (pixel > 255) pixel = 255;
 
             if (m_invertVertical) {
-                m_cache->setPixel(c - firstBin, m_model->getHeight() - y - 1,
-                                  pixel);
+                m_cache->setPixel(c, cacheHeight - y - 1, pixel);
             } else {
-                m_cache->setPixel(c - firstBin, y, pixel);
+                m_cache->setPixel(c, y, pixel);
             }
         }
     }
 }
 

     bool illuminate = v->shouldIlluminateLocalFeatures(this, illuminatePos);
     char labelbuf[10];
 
     for (int sx = sx0; sx <= sx1; ++sx) {
 
-        int scx = 0;
-        if (sx > int(m_cacheStart)) scx = sx - m_cacheStart;
-        
 	int fx = sx * int(modelResolution);
 
 	if (fx + int(modelResolution) <= int(modelStart) ||
 	    fx > int(modelEnd)) continue;
 

         
 	for (int sy = symin; sy < symax; ++sy) {
 
 	    int ry0 = h - ((sy - symin) * h) / (symax - symin) - 1;
 	    QRgb pixel = qRgb(255, 255, 255);
-	    if (scx >= 0 && scx < m_cache->width() &&
+	    if (sx >= 0 && sx < m_cache->width() &&
 		sy >= 0 && sy < m_cache->height()) {
-		pixel = m_cache->pixel(scx, sy);
+		pixel = m_cache->pixel(sx, sy);
 	    }
 
 	    QRect r(rx0, ry0 - h / (symax - symin) - 1,
                     rw, h / (symax - symin) + 1);
 

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

             float mag = 0.0, div = 0.0;
             int max = 0;
 
             for (int sx = sx0i; sx <= sx1i; ++sx) {
 
-                int scx = 0;
-                if (sx > int(m_cacheStart)) scx = sx - int(m_cacheStart);
-        
-                if (scx < 0 || scx >= m_cache->width()) continue;
+                if (sx < 0 || sx >= m_cache->width()) continue;
 
                 for (int sy = sy0i; sy <= sy1i; ++sy) {
 
                     if (sy < 0 || sy >= m_cache->height()) continue;
 

                     if (sx == sx0i) prop *= (sx + 1) - sx0;
                     if (sx == sx1i) prop *= sx1 - sx;
                     if (sy == sy0i) prop *= (sy + 1) - sy0;
                     if (sy == sy1i) prop *= sy1 - sy;
 
-                    mag += prop * m_cache->pixelIndex(scx, sy);
-                    max = std::max(max, m_cache->pixelIndex(scx, sy));
+                    mag += prop * m_cache->pixelIndex(sx, sy);
+                    max = std::max(max, m_cache->pixelIndex(sx, sy));
                     div += prop;
                 }
             }
 
             if (div != 0) mag /= div;