comparison layer/Colour3DPlotRenderer.cpp @ 1121:d930ff725f64 spectrogram-minor-refactor

Wiring through the magnitude range updates

 {
     return render(v, paint, rect, true);
 }
 
 QRect
-Colour3DPlotRenderer::getLargestUncachedRect()
-{
+Colour3DPlotRenderer::getLargestUncachedRect(const LayerGeometryProvider *v)
+{
+    RenderType renderType = decideRenderType(v);
+
+    if (renderType == DirectTranslucent) {
+        return QRect(); // never cached
+    }
+
     int h = m_cache.getSize().height();
 
     QRect areaLeft(0, 0, m_cache.getValidLeft(), h);
     QRect areaRight(m_cache.getValidRight(), 0,
                     m_cache.getSize().width() - m_cache.getValidRight(), h);

 
     m_magCache.resize(v->getPaintSize().width());
     m_magCache.setZoomLevel(v->getZoomLevel());
     
     if (renderType == DirectTranslucent) {
-        renderDirectTranslucent(v, paint, rect);
-        //!!! mag range!
-
-        //!!! a dev debug check
-        if (!m_magCache.areColumnsSet(x0, x1 - x0)) {
-            cerr << "Columns (" << x0 << " -> " << x1-x0
-                 << ") not set in mag cache" << endl;
-            throw std::logic_error("Columns not set in mag cache");
-        }
-
-        //!!! this is wrong
-        MagnitudeRange range = m_magCache.getRange(x0, x1-x0);
-
-        return { rect, range }; //!!! this return arg is not very useful
+        MagnitudeRange range = renderDirectTranslucent(v, paint, rect);
+        return { rect, range };
     }
     
     cerr << "cache start " << m_cache.getStartFrame()
          << " valid left " << m_cache.getValidLeft()
          << " valid right " << m_cache.getValidRight()

             // cache is valid for the complete requested area
             paint.drawImage(rect, m_cache.getImage(), rect);
 
             //!!! a dev debug check
             if (!m_magCache.areColumnsSet(x0, x1 - x0)) {
-                cerr << "Columns (" << x0 << " -> " << x1-x0
+                cerr << "NB Columns (" << x0 << " -> " << x1-x0
                      << ") not set in mag cache" << endl;
-                throw std::logic_error("Columns not set in mag cache");
+//                throw std::logic_error("Columns not set in mag cache");
             }
             
             MagnitudeRange range = m_magCache.getRange(x0, x1-x0);
 
             return { rect, range };

         throw std::logic_error("internal error: failed to render entire requested rect even when not time-constrained");
     }
 
     //!!! a dev debug check
     if (!m_magCache.areColumnsSet(x0, x1 - x0)) {
-        cerr << "Columns (" << x0 << " -> " << x1-x0
+        cerr << "NB Columns (" << x0 << " -> " << x1-x0
              << ") not set in mag cache" << endl;
-        throw std::logic_error("Columns not set in mag cache");
+//        throw std::logic_error("Columns not set in mag cache");
     }
     
     MagnitudeRange range = m_magCache.getRange(x0, x1-x0);
     
     return { pr, range };

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

 //                     << ", minbin " << minbin << ", maxbin " << maxbin << endl;
                 
             ColumnOp::Column column =
                 vector<float>(fullColumn.data() + minbin,
                               fullColumn.data() + maxbin + 1);
+
+            magRange.sample(column);
 
 //!!! fft scale                if (m_colourScale != ColourScaleType::Phase) {
 //                    column = ColumnOp::fftScale(column, m_fftSize);
 //                }
 

                      text,
                      PaintAssistant::OutlinedText);
 	    }
 	}
     }
-   
+
+    return magRange;
 }
 
 void
 Colour3DPlotRenderer::renderToCachePixelResolution(const LayerGeometryProvider *v,
                                                    int x0, int repaintWidth,

     }
 
     m_cache.drawImage(paintedLeft, attainedWidth,
                       m_drawBuffer,
                       paintedLeft - x0, attainedWidth);
+
+    for (int i = 0; in_range_for(m_magRanges, i); ++i) {
+        m_magCache.sampleColumn(i, m_magRanges.at(i));
+    }
 }
 
 void
 Colour3DPlotRenderer::renderToCacheBinResolution(const LayerGeometryProvider *v,
                                                  int x0, int repaintWidth)

     if (targetWidth > 0) {
         m_cache.drawImage(targetLeft, targetWidth,
                           scaled,
                           sourceLeft, sourceWidth);
     }
+    
+    for (int i = 0; i < targetWidth; ++i) {
+        int sourceIx = int((double(i) / targetWidth) * sourceWidth);
+        if (in_range_for(m_magRanges, sourceIx)) {
+            m_magCache.sampleColumn(i, m_magRanges.at(sourceIx));
+        }
+    }
 }
 
 int
 Colour3DPlotRenderer::renderDrawBuffer(int w, int h,
                                        const vector<int> &binforx,

     int columnCount = 0;
     
     vector<float> preparedColumn;
 
     int modelWidth = sourceModel->getWidth();
-    cerr << "modelWidth " << modelWidth << endl;
-            
+
+    cerr << "modelWidth " << modelWidth << ", divisor " << divisor << endl;
+
     for (int x = start; x != finish; x += step) {
 
         // x is the on-canvas pixel coord; sx (later) will be the
         // source column index
         
         ++columnCount;
 
 #ifdef DEBUG_SPECTROGRAM_REPAINT
-        cerr << "x = " << x << endl;
+        cerr << "x = " << x << ", binforx[x] = " << binforx[x] << endl;
 #endif
         
         if (binforx[x] < 0) continue;
 
         int sx0 = binforx[x] / divisor;

         if (sx0 < 0) sx0 = sx1 - 1;
         if (sx0 < 0) continue;
         if (sx1 <= sx0) sx1 = sx0 + 1;
 
         vector<float> pixelPeakColumn;
+        MagnitudeRange magRange;
         
         for (int sx = sx0; sx < sx1; ++sx) {
 
 #ifdef DEBUG_SPECTROGRAM_REPAINT
             cerr << "sx = " << sx << endl;

 
 //!!! fft scale                if (m_colourScale != ColourScaleType::Phase) {
 //                    column = ColumnOp::fftScale(column, m_fftSize);
 //                }
 
-                MagnitudeRange r;
-                r.sample(column);
-                int magColIndex = sx - int(m_magCache.getStartFrame() /
-                                           sourceModel->getResolution());
-                cerr << "magColIndex = " << magColIndex << endl;
-                m_magCache.sampleColumn(magColIndex, r);
+                magRange.sample(column);
                 
 //!!! extents                recordColumnExtents(column,
 //                                    sx,
 //                                    overallMag,
 //                                    overallMagChanged);

                 }
             }
         }
 
         if (!pixelPeakColumn.empty()) {
+
             for (int y = 0; y < h; ++y) {
                 int py;
                 if (m_params.invertVertical) {
                     py = y;
                 } else {

                 m_drawBuffer.setPixel
                     (x,
                      py,
                      m_params.colourScale.getPixel(pixelPeakColumn[y]));
             }
+            
+            m_magRanges.push_back(magRange);
         }
 
         double fractionComplete = double(columnCount) / double(w);
         if (timer.outOfTime(fractionComplete)) {
+            cerr << "out of time" << endl;
             return columnCount;
         }
     }
 
     return columnCount;

         if (sx0 < 0) sx0 = sx1 - 1;
         if (sx0 < 0) continue;
         if (sx1 <= sx0) sx1 = sx0 + 1;
 
         vector<float> pixelPeakColumn;
+        MagnitudeRange magRange;
         
         for (int sx = sx0; sx < sx1; ++sx) {
 
             if (sx < 0 || sx >= modelWidth) {
                 continue;

                 
                 ColumnOp::Column column =
                     vector<float>(fullColumn.data() + minbin,
                                   fullColumn.data() + maxbin + 1);
 
+                magRange.sample(column);
+                
 //!!! fft scale                if (m_colourScale != ColourScaleType::Phase) {
 //                    column = ColumnOp::fftScale(column, getFFTSize());
 //                }
 
 //!!! extents                recordColumnExtents(column,

                 }
             }
         }
 
         if (!pixelPeakColumn.empty()) {
+            
             for (FFTModel::PeakSet::const_iterator pi = peakfreqs.begin();
                  pi != peakfreqs.end(); ++pi) {
 
                 int bin = pi->first;
                 double freq = pi->second;

                 m_drawBuffer.setPixel
                     (x,
                      iy,
                      m_params.colourScale.getPixel(value));
             }
+
+            m_magRanges.push_back(magRange);
         }
 
         double fractionComplete = double(columnCount) / double(w);
         if (timer.outOfTime(fractionComplete)) {
             return columnCount;

              m_params.colourScale.getColourForPixel
              (pixel, m_params.colourRotation).rgb());
     }
 
     m_drawBuffer.fill(0);
+    m_magRanges.clear();
 }
 
 void
 Colour3DPlotRenderer::clearDrawBuffer(int w, int h)
 {
     if (m_drawBuffer.width() < w || m_drawBuffer.height() != h) {
         recreateDrawBuffer(w, h);
     } else {
         m_drawBuffer.fill(0);
-    }
-}
-
-
+        m_magRanges.clear();
+    }
+}
+
+