comparison layer/TimeValueLayer.cpp @ 553:97e60a895211

* Add "plot derivatives" option to time value layer (scale is not always right)

     m_editingCommand(0),
     m_colourMap(0),
     m_plotStyle(PlotConnectedPoints),
     m_verticalScale(AutoAlignScale),
     m_drawSegmentDivisions(true),
+    m_derivative(false),
     m_scaleMinimum(0),
     m_scaleMaximum(0)
 {
     
 }

     PropertyList list = SingleColourLayer::getProperties();
     list.push_back("Plot Type");
     list.push_back("Vertical Scale");
     list.push_back("Scale Units");
     list.push_back("Draw Segment Division Lines");
+    list.push_back("Show Derivative");
     return list;
 }
 
 QString
 TimeValueLayer::getPropertyLabel(const PropertyName &name) const
 {
     if (name == "Plot Type") return tr("Plot Type");
     if (name == "Vertical Scale") return tr("Vertical Scale");
     if (name == "Scale Units") return tr("Scale Units");
     if (name == "Draw Segment Division Lines") return tr("Draw Segment Division Lines");
+    if (name == "Show Derivative") return tr("Show Derivative");
     return SingleColourLayer::getPropertyLabel(name);
 }
 
 QString
 TimeValueLayer::getPropertyIconName(const PropertyName &name) const
 {
     if (name == "Draw Segment Division Lines") return "lines";
+    if (name == "Show Derivative") return "derivative";
     return "";
 }
 
 Layer::PropertyType
 TimeValueLayer::getPropertyType(const PropertyName &name) const

     if (name == "Plot Type") return ValueProperty;
     if (name == "Vertical Scale") return ValueProperty;
     if (name == "Scale Units") return UnitsProperty;
     if (name == "Colour" && m_plotStyle == PlotSegmentation) return ValueProperty;
     if (name == "Draw Segment Division Lines") return ToggleProperty;
+    if (name == "Show Derivative") return ToggleProperty;
     return SingleColourLayer::getPropertyType(name);
 }
 
 QString
 TimeValueLayer::getPropertyGroupName(const PropertyName &name) const
 {
     if (name == "Vertical Scale" || name == "Scale Units") {
         return tr("Scale");
     }
-    if (name == "Plot Type" || name == "Draw Segment Division Lines") {
+    if (name == "Plot Type" || name == "Draw Segment Division Lines" ||
+        name == "Show Derivative") {
         return tr("Plot Type");
     }
     return SingleColourLayer::getPropertyGroupName(name);
 }
 

 
         if (min) *min = 0;
         if (max) *max = 0;
         if (deflt) *deflt = 1;
         val = (m_drawSegmentDivisions ? 1.0 : 0.0);
+
+    } else if (name == "Show Derivative") {
+
+        if (min) *min = 0;
+        if (max) *max = 0;
+        if (deflt) *deflt = 0;
+        val = (m_derivative ? 1.0 : 0.0);
 
     } else {
 	
 	val = SingleColourLayer::getPropertyRangeAndValue(name, min, max, deflt);
     }

                 (UnitDatabase::getInstance()->getUnitById(value));
             emit modelChanged();
         }
     } else if (name == "Draw Segment Division Lines") {
         setDrawSegmentDivisions(value > 0.5);
+    } else if (name == "Show Derivative") {
+        setShowDerivative(value > 0.5);
     } else {
         SingleColourLayer::setProperty(name, value);
     }
 }
 

     if (m_drawSegmentDivisions == draw) return;
     m_drawSegmentDivisions = draw;
     emit layerParametersChanged();
 }
 
+void
+TimeValueLayer::setShowDerivative(bool show)
+{
+    if (m_derivative == show) return;
+    m_derivative = show;
+    emit layerParametersChanged();
+}
+
 bool
 TimeValueLayer::isLayerScrollable(const View *v) const
 {
     // We don't illuminate sections in the line or curve modes, so
     // they're always scrollable

     if (!m_model) return false;
     min = m_model->getValueMinimum();
     max = m_model->getValueMaximum();
     logarithmic = (m_verticalScale == LogScale);
     unit = m_model->getScaleUnits();
+    if (m_derivative) {
+        max = std::max(fabsf(min), fabsf(max));
+        min = -max;
+    }
     return true;
 }
 
 bool
 TimeValueLayer::getDisplayExtents(float &min, float &max) const

     if (!m_model || shouldAutoAlign()) return false;
 
     if (m_scaleMinimum == m_scaleMaximum) {
         min = m_model->getValueMinimum();
         max = m_model->getValueMaximum();
-        return true;
-    }
-
-    min = m_scaleMinimum;
-    max = m_scaleMaximum;
+    } else {
+        min = m_scaleMinimum;
+        max = m_scaleMaximum;
+    }
+
+    if (m_derivative) {
+        max = std::max(fabsf(min), fabsf(max));
+        min = -max;
+    }
 
 #ifdef DEBUG_TIME_VALUE_LAYER
     std::cerr << "TimeValueLayer::getDisplayExtents: min = " << min << ", max = " << max << std::endl;
 #endif
 

     getDisplayExtents(dmin, dmax);
 
     int nr = mapper->getPositionForValue(dmax - dmin);
 
 #ifdef DEBUG_TIME_VALUE_LAYER
-    int n0 = mapper->getPositionForValue(dmax);
-    int n1 = mapper->getPositionForValue(dmin);
-    int nr = n1 - n0;
-    if (nr < 0) nr = -nr;
-
-    std::cerr << "TimeValueLayer::getCurrentVerticalZoomStep: dmin = " << dmin << ", dmax = " << dmax << ", n0 = " << n0 << ", n1 = " << n1 << ", nr = " << nr << std::endl;
+    std::cerr << "TimeValueLayer::getCurrentVerticalZoomStep: dmin = " << dmin << ", dmax = " << dmax << ", nr = " << nr << std::endl;
 #endif
 
     delete mapper;
 
     return 100 - nr;

 //    Profiler profiler("TimeValueLayer::paint", true);
 
     int x0 = rect.left(), x1 = rect.right();
     long frame0 = v->getFrameForX(x0);
     long frame1 = v->getFrameForX(x1);
+    if (m_derivative) --frame0;
 
     SparseTimeValueModel::PointList points(m_model->getPoints
 					   (frame0, frame1));
     if (points.empty()) return;
 

     }
     
     for (SparseTimeValueModel::PointList::const_iterator i = points.begin();
 	 i != points.end(); ++i) {
 
+        if (m_derivative && i == points.begin()) continue;
+        
 	const SparseTimeValueModel::Point &p(*i);
 
+        float value = p.value;
+        if (m_derivative) {
+            SparseTimeValueModel::PointList::const_iterator j = i;
+            --j;
+            value -= j->value;
+        }
+
 	int x = v->getXForFrame(p.frame);
-	int y = getYForValue(v, p.value);
+	int y = getYForValue(v, value);
 
         if (m_plotStyle != PlotSegmentation) {
             textY = y - paint.fontMetrics().height()
                       + paint.fontMetrics().ascent();
             if (textY < paint.fontMetrics().ascent() + 1) {

 	SparseTimeValueModel::PointList::const_iterator j = i;
 	++j;
 
 	if (j != points.end()) {
 	    const SparseTimeValueModel::Point &q(*j);
+            float nvalue = q.value;
+            if (m_derivative) nvalue -= p.value;
 	    nx = v->getXForFrame(q.frame);
-	    ny = getYForValue(v, q.value);
+	    ny = getYForValue(v, nvalue);
 	    haveNext = true;
         }
 
 //        std::cout << "frame = " << p.frame << ", x = " << x << ", haveNext = " << haveNext 
 //                  << ", nx = " << nx << std::endl;

 	if (w < 1) w = 1;
 	paint.setPen(getBaseQColor());
 
 	if (m_plotStyle == PlotSegmentation) {
             paint.setPen(getForegroundQColor(v));
-            paint.setBrush(getColourForValue(v, p.value));
+            paint.setBrush(getColourForValue(v, value));
 	} else if (m_plotStyle == PlotLines ||
 		   m_plotStyle == PlotCurve) {
 	    paint.setBrush(Qt::NoBrush);
 	} else {
 	    paint.setBrush(brushColour);

 
 void
 TimeValueLayer::drawEnd(View *, QMouseEvent *)
 {
 #ifdef DEBUG_TIME_VALUE_LAYER
-    std::cerr << "TimeValueLayer::drawEnd(" << e->x() << "," << e->y() << ")" << std::endl;
+    std::cerr << "TimeValueLayer::drawEnd" << std::endl;
 #endif
     if (!m_model || !m_editing) return;
     finish(m_editingCommand);
     m_editingCommand = 0;
     m_editing = false;

 
 void
 TimeValueLayer::editEnd(View *, QMouseEvent *)
 {
 #ifdef DEBUG_TIME_VALUE_LAYER
-    std::cerr << "TimeValueLayer::editEnd(" << e->x() << "," << e->y() << ")" << std::endl;
+    std::cerr << "TimeValueLayer::editEnd" << std::endl;
 #endif
     if (!m_model || !m_editing) return;
 
     if (m_editingCommand) {
 

 TimeValueLayer::toXml(QTextStream &stream,
                       QString indent, QString extraAttributes) const
 {
     SingleColourLayer::toXml(stream, indent,
                              extraAttributes +
-                             QString(" colourMap=\"%1\" plotStyle=\"%2\" verticalScale=\"%3\" scaleMinimum=\"%4\" scaleMaximum=\"%5\" drawDivisions=\"%6\" ")
+                             QString(" colourMap=\"%1\" plotStyle=\"%2\" verticalScale=\"%3\" scaleMinimum=\"%4\" scaleMaximum=\"%5\" drawDivisions=\"%6\" derivative=\"%7\" ")
                              .arg(m_colourMap)
                              .arg(m_plotStyle)
                              .arg(m_verticalScale)
                              .arg(m_scaleMinimum)
                              .arg(m_scaleMaximum)
-                             .arg(m_drawSegmentDivisions ? "true" : "false"));
+                             .arg(m_drawSegmentDivisions ? "true" : "false")
+                             .arg(m_derivative ? "true" : "false"));
 }
 
 void
 TimeValueLayer::setProperties(const QXmlAttributes &attributes)
 {

     if (ok) setVerticalScale(scale);
 
     bool draw = (attributes.value("drawDivisions").trimmed() == "true");
     setDrawSegmentDivisions(draw);
 
+    bool derivative = (attributes.value("derivative").trimmed() == "true");
+    setShowDerivative(derivative);
+
     float min = attributes.value("scaleMinimum").toFloat(&ok);
     float max = attributes.value("scaleMaximum").toFloat(&alsoOk);
 #ifdef DEBUG_TIME_VALUE_LAYER
     std::cerr << "from properties: min = " << min << ", max = " << max << std::endl;
 #endif