comparison layer/TimeValueLayer.cpp @ 615:156a120345ae

Add discrete-curve drawing mode for time-value layer

         val = m_colourMap;
 
     } else if (name == "Plot Type") {
 	
 	if (min) *min = 0;
-	if (max) *max = 5;
+	if (max) *max = 6;
         if (deflt) *deflt = int(PlotConnectedPoints);
 	
 	val = int(m_plotStyle);
 
     } else if (name == "Vertical Scale") {

 	case 1: return tr("Stems");
 	case 2: return tr("Connected Points");
 	case 3: return tr("Lines");
 	case 4: return tr("Curve");
 	case 5: return tr("Segmentation");
+	case 6: return tr("Discrete Curves");
 	}
     } else if (name == "Vertical Scale") {
 	switch (value) {
 	default:
 	case 0: return tr("Auto-Align");

 {
     // We don't illuminate sections in the line or curve modes, so
     // they're always scrollable
 
     if (m_plotStyle == PlotLines ||
-	m_plotStyle == PlotCurve) return true;
+	m_plotStyle == PlotCurve ||
+        m_plotStyle == PlotDiscreteCurves) return true;
 
     QPoint discard;
     return !v->shouldIlluminateLocalFeatures(this, discard);
 }
 

             paint.drawLine(x0, originY, x1, originY);
             paint.restore();
         }
     }
     
+    int prevFrame = 0;
+
     for (SparseTimeValueModel::PointList::const_iterator i = points.begin();
 	 i != points.end(); ++i) {
 
         if (m_derivative && i == points.begin()) continue;
         

             value -= j->value;
         }
 
 	int x = v->getXForFrame(p.frame);
 	int y = getYForValue(v, value);
+
+        bool gap = false;
+        if (m_plotStyle == PlotDiscreteCurves) { 
+            gap = (p.frame > prevFrame &&
+                   (p.frame - prevFrame >= m_model->getResolution() * 2));
+        }
 
         if (m_plotStyle != PlotSegmentation) {
             textY = y - paint.fontMetrics().height()
                       + paint.fontMetrics().ascent();
             if (textY < paint.fontMetrics().ascent() + 1) {
                 textY = paint.fontMetrics().ascent() + 1;
             }
         }
 
 	bool haveNext = false;
-	int nx = v->getXForFrame(v->getModelsEndFrame());
+        int nf = v->getModelsEndFrame();
+	int nx = v->getXForFrame(nf);
 	int ny = y;
 
 	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);
+            nf = q.frame;
+	    nx = v->getXForFrame(nf);
 	    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) {
+
+        if (m_plotStyle == PlotDiscreteCurves) {
+            paint.setPen(QPen(getBaseQColor(), 3));
+            paint.setBrush(Qt::NoBrush);
+        } else if (m_plotStyle == PlotSegmentation) {
             paint.setPen(getForegroundQColor(v));
             paint.setBrush(getColourForValue(v, value));
 	} else if (m_plotStyle == PlotLines ||
 		   m_plotStyle == PlotCurve) {
+            paint.setPen(getBaseQColor());
 	    paint.setBrush(Qt::NoBrush);
 	} else {
+            paint.setPen(getBaseQColor());
 	    paint.setBrush(brushColour);
 	}	    
 
 	if (m_plotStyle == PlotStems) {
 /*

 
 	    //!!! not equipped to illuminate the right section in line
 	    //or curve mode
 
 	    if (m_plotStyle != PlotCurve &&
+                m_plotStyle != PlotDiscreteCurves &&
 		m_plotStyle != PlotLines) {
 		paint.setPen(getForegroundQColor(v));
 	    }	    
 	}
 
 	if (m_plotStyle != PlotLines &&
 	    m_plotStyle != PlotCurve &&
+            m_plotStyle != PlotDiscreteCurves &&
 	    m_plotStyle != PlotSegmentation) {
             if (m_plotStyle != PlotStems ||
                 w > 1) {
                 paint.drawRect(x, y - 1, w, 2);
             }
 	}
 
 	if (m_plotStyle == PlotConnectedPoints ||
 	    m_plotStyle == PlotLines ||
+            m_plotStyle == PlotDiscreteCurves ||
 	    m_plotStyle == PlotCurve) {
 
 	    if (haveNext) {
 
 		if (m_plotStyle == PlotConnectedPoints) {

 		    float x1 = nx + float(w)/2;
 		    
 		    float y0 = y;
 		    float y1 = ny;
 
-		    if (pointCount == 0) {
+                    if (m_plotStyle == PlotDiscreteCurves) {
+                        bool nextGap = nf - p.frame >= m_model->getResolution() * 2;
+                        if (nextGap) {
+                            x1 = x0;
+                            y1 = y0;
+                        }
+                    }
+
+		    if (pointCount == 0 || gap) {
 			path.moveTo((x0 + x1) / 2, (y0 + y1) / 2);
 		    }
 		    ++pointCount;
 
 		    if (nx - x > 5) {

             if (!haveNext || nx > x + 6 + paint.fontMetrics().width(p.label)) {
                 v->drawVisibleText(paint, x + 5, textY, p.label, View::OutlinedText);
 //                paint.drawText(x + 5, textY, p.label);
             }
 	}
-    }
-
-    if ((m_plotStyle == PlotCurve || m_plotStyle == PlotLines)
+
+        prevFrame = p.frame;
+    }
+
+    if ((m_plotStyle == PlotCurve || m_plotStyle == PlotDiscreteCurves ||
+         m_plotStyle == PlotLines)
         && !path.isEmpty()) {
 	paint.setRenderHint(QPainter::Antialiasing, pointCount <= v->width());
 	paint.drawPath(path);
     }