comparison layer/Colour3DPlotLayer.cpp @ 374:64e84e5efb76 spectrogram-cache-rejig

* Merge from trunk

     m_cache(0),
     m_cacheStart(0),
     m_colourScale(LinearScale),
     m_colourMap(0),
     m_normalizeColumns(false),
-    m_normalizeVisibleArea(false)
+    m_normalizeVisibleArea(false),
+    m_invertVertical(false)
 {
     
 }
 
 Colour3DPlotLayer::~Colour3DPlotLayer()

     PropertyList list;
     list.push_back("Colour");
     list.push_back("Colour Scale");
     list.push_back("Normalize Columns");
     list.push_back("Normalize Visible Area");
+    list.push_back("Invert Vertical Scale");
     return list;
 }
 
 QString
 Colour3DPlotLayer::getPropertyLabel(const PropertyName &name) const
 {
     if (name == "Colour") return tr("Colour");
     if (name == "Colour Scale") return tr("Scale");
     if (name == "Normalize Columns") return tr("Normalize Columns");
     if (name == "Normalize Visible Area") return tr("Normalize Visible Area");
+    if (name == "Invert Vertical Scale") return tr("Invert Vertical Scale");
+    return "";
+}
+
+QString
+Colour3DPlotLayer::getPropertyIconName(const PropertyName &name) const
+{
+    if (name == "Normalize Columns") return "normalise-columns";
+    if (name == "Normalize Visible Area") return "normalise";
+    if (name == "Invert Vertical Scale") return "invert-vertical";
     return "";
 }
 
 Layer::PropertyType
 Colour3DPlotLayer::getPropertyType(const PropertyName &name) const
 {
     if (name == "Normalize Columns") return ToggleProperty;
     if (name == "Normalize Visible Area") return ToggleProperty;
+    if (name == "Invert Vertical Scale") return ToggleProperty;
     return ValueProperty;
 }
 
 QString
 Colour3DPlotLayer::getPropertyGroupName(const PropertyName &name) const
 {
     if (name == "Normalize Columns" ||
         name == "Normalize Visible Area" ||
+        name == "Invert Vertical Scale" ||
 	name == "Colour Scale") return tr("Scale");
     return QString();
 }
 
 int

 
     } else if (name == "Normalize Visible Area") {
 	
         *deflt = 0;
 	val = (m_normalizeVisibleArea ? 1 : 0);
+
+    } else if (name == "Invert Vertical Scale") {
+	
+        *deflt = 0;
+	val = (m_invertVertical ? 1 : 0);
 
     } else {
 	val = Layer::getPropertyRangeAndValue(name, min, max, deflt);
     }
 

         setColourMap(value);
     } else if (name == "Normalize Columns") {
 	setNormalizeColumns(value ? true : false);
     } else if (name == "Normalize Visible Area") {
 	setNormalizeVisibleArea(value ? true : false);
+    } else if (name == "Invert Vertical Scale") {
+	setInvertVertical(value ? true : false);
     }
 }
 
 void
 Colour3DPlotLayer::setColourScale(ColourScale scale)

 Colour3DPlotLayer::getNormalizeVisibleArea() const
 {
     return m_normalizeVisibleArea;
 }
 
+void
+Colour3DPlotLayer::setInvertVertical(bool n)
+{
+    if (m_invertVertical == n) return;
+    m_invertVertical = n;
+    cacheInvalid();
+    emit layerParametersChanged();
+}
+
+bool
+Colour3DPlotLayer::getInvertVertical() const
+{
+    return m_invertVertical;
+}
+
 bool
 Colour3DPlotLayer::isLayerScrollable(const View *v) const
 {
     if (m_normalizeVisibleArea) return false;
     QPoint discard;

     int f0 = sx0 * modelResolution;
     int f1 =  f0 + modelResolution;
 
     float binHeight = float(v->height()) / m_model->getHeight();
     int sy = int((v->height() - y) / binHeight);
+
+    if (m_invertVertical) sy = m_model->getHeight() - sy - 1;
 
     float value = m_model->getValueAt(sx0, sy);
 
 //    std::cerr << "bin value (" << sx0 << "," << sy << ") is " << value << std::endl;
     

     int step = m_model->getHeight() / count;
     if (step == 0) step = 1;
 
     for (size_t i = 0; i < m_model->getHeight(); ++i) {
 
-        if ((i % step) != 0) continue;
+        size_t idx = i;
+        if (m_invertVertical) idx = m_model->getHeight() - idx - 1;
+
+        if ((idx % step) != 0) continue;
 
 	int y0 = int(v->height() - (i * binHeight) - 1);
 	
-	QString text = m_model->getBinName(i);
-	if (text == "") text = QString("[%1]").arg(i + 1);
+	QString text = m_model->getBinName(idx);
+	if (text == "") text = QString("[%1]").arg(idx + 1);
 
 	paint.drawLine(cw, y0, w, y0);
 
 	int cy = int(y0 - (step * binHeight)/2);
 	int ty = cy + paint.fontMetrics().ascent()/2;

 
             int pixel = int(((value - min) * 256) / (max - min));
             if (pixel < 0) pixel = 0;
             if (pixel > 255) pixel = 255;
 
-            m_cache->setPixel(c - firstBin, y, pixel);
+            if (m_invertVertical) {
+                m_cache->setPixel(c - firstBin, m_model->getHeight() - y - 1,
+                                  pixel);
+            } else {
+                m_cache->setPixel(c - firstBin, y, pixel);
+            }
         }
     }
 }
 
 void

 
     if (sx0 > 0) --sx0;
     fillCache(sx0 < 0 ? 0 : sx0,
               sx1 < 0 ? 0 : sx1);
 
+#ifdef DEBUG_COLOUR_3D_PLOT_LAYER_PAINT
+    std::cerr << "Colour3DPlotLayer::paint: height = "<< m_model->getHeight() << ", modelStart = " << modelStart << ", resolution = " << modelResolution << ", model rate = " << m_model->getSampleRate() << std::endl;
+#endif
+
     if (int(m_model->getHeight()) >= v->height() ||
-        int(modelResolution) < v->getZoomLevel() / 2) {
+        int(modelResolution * m_model->getSampleRate()) < v->getZoomLevel() / 2) {
+#ifdef DEBUG_COLOUR_3D_PLOT_LAYER_PAINT
+        std::cerr << "calling paintDense" << std::endl;
+#endif
         paintDense(v, paint, rect);
         return;
     }
 
 #ifdef DEBUG_COLOUR_3D_PLOT_LAYER_PAINT
-    std::cerr << "Colour3DPlotLayer::paint: w " << w << ", h " << h << ", sx0 " << sx0 << ", sx1 " << sx1 << ", sw " << sw << ", sh " << sh << std::endl;
+    std::cerr << "Colour3DPlotLayer::paint: w " << x1-x0 << ", h " << h << ", sx0 " << sx0 << ", sx1 " << sx1 << ", sw " << sx1-sx0 << ", sh " << sh << std::endl;
     std::cerr << "Colour3DPlotLayer: sample rate is " << m_model->getSampleRate() << ", resolution " << m_model->getResolution() << std::endl;
 #endif
 
     QPoint illuminatePos;
     bool illuminate = v->shouldIlluminateLocalFeatures(this, illuminatePos);

         int scx = 0;
         if (sx > int(m_cacheStart)) scx = sx - m_cacheStart;
         
 	int fx = sx * int(modelResolution);
 
-	if (fx + int(modelResolution) < int(modelStart) ||
+	if (fx + int(modelResolution) <= int(modelStart) ||
 	    fx > int(modelEnd)) continue;
 
         int rx0 = v->getXForFrame(int((fx + int(modelStart)) * srRatio));
 	int rx1 = v->getXForFrame(int((fx + int(modelStart) + int(modelResolution) + 1) * srRatio));
 

 
     QImage img(w, h, QImage::Format_RGB32);
 
     for (int x = x0; x < x1; ++x) {
 
-        long xf = long(v->getFrameForX(x) / srRatio);
+        long xf = long(v->getFrameForX(x));
         if (xf < 0) {
             for (int y = 0; y < h; ++y) {
                 img.setPixel(x - x0, y, m_cache->color(0));
             }
             continue;
         }
+
+        xf /= srRatio;
 
         float sx0 = (float(xf) - modelStart) / modelResolution;
         float sx1 = (float(v->getFrameForX(x+1) / srRatio) - modelStart) / modelResolution;
             
         int sx0i = int(sx0 + 0.001);