comparison layer/Colour3DPlotRenderer.cpp @ 1117:64709d4d09ef spectrogram-minor-refactor

Fix translucent mode for spectrogram

     COPYING included with this distribution for more information.
 */
 
 #include "Colour3DPlotRenderer.h"
 #include "RenderTimer.h"
+
+#include "base/Profiler.h"
 
 #include "data/model/DenseThreeDimensionalModel.h"
 #include "data/model/Dense3DModelPeakCache.h"
 #include "data/model/FFTModel.h"
 

     if (!m_params.alwaysOpaque && !m_params.interpolate) {
 
         // consider translucent option -- only if not smoothing & not
         // explicitly requested opaque & sufficiently zoomed-in
         
-        if (model->getHeight() < v->getPaintHeight() &&
-            relativeBinResolution >= 2 * zoomLevel) {
+        if (model->getHeight() * 3 < v->getPaintHeight() &&
+            relativeBinResolution >= 3 * zoomLevel) {
             return DirectTranslucent;
         }
     }
 
     if (relativeBinResolution > zoomLevel) {

 void
 Colour3DPlotRenderer::renderDirectTranslucent(const LayerGeometryProvider *v,
                                               QPainter &paint,
                                               QRect rect)
 {
+    Profiler profiler("Colour3DPlotRenderer::renderDirectTranslucent");
+
     QPoint illuminatePos;
     bool illuminate = v->shouldIlluminateLocalFeatures
         (m_sources.verticalBinLayer, illuminatePos);
 
     const DenseThreeDimensionalModel *model = m_sources.source;

 Colour3DPlotRenderer::renderToCachePixelResolution(const LayerGeometryProvider *v,
                                                    int x0, int repaintWidth,
                                                    bool rightToLeft,
                                                    bool timeConstrained)
 {
+    Profiler profiler("Colour3DPlotRenderer::renderToCachePixelResolution");
     cerr << "renderToCachePixelResolution" << endl;
     
     // Draw to the draw buffer, and then copy from there. The draw
     // buffer is at the same resolution as the target in the cache, so
     // no extra scaling needed.

 
 void
 Colour3DPlotRenderer::renderToCacheBinResolution(const LayerGeometryProvider *v,
                                                  int x0, int repaintWidth)
 {
+    Profiler profiler("Colour3DPlotRenderer::renderToCacheBinResolution");
     cerr << "renderToCacheBinResolution" << endl;
     
     // Draw to the draw buffer, and then scale-copy from there. Draw
     // buffer is at bin resolution, i.e. buffer x == source column
     // number. We use toolkit smooth scaling for interpolation.