comparison layer/TimeValueLayer.cpp @ 526:e60e6fccfe4e

* fix incorrect default scale extents when loading layer from a file
  in which both min and max have been saved as 0

 #include <QMessageBox>
 #include <QInputDialog>
 
 #include <iostream>
 #include <cmath>
+
+//#define DEBUG_TIME_VALUE_LAYER 1
 
 TimeValueLayer::TimeValueLayer() :
     SingleColourLayer(),
     m_model(0),
     m_editing(false),

     }
     if (m_model && m_model->getRDFTypeURI().endsWith("Change")) {
         setPlotStyle(PlotSegmentation);
     }
 
-//    std::cerr << "TimeValueLayer::setModel(" << model << ")" << std::endl;
+#ifdef DEBUG_TIME_VALUE_LAYER
+    std::cerr << "TimeValueLayer::setModel(" << model << ")" << std::endl;
+#endif
 
     emit modelReplaced();
 }
 
 Layer::PropertyList

     }
 
     min = m_scaleMinimum;
     max = m_scaleMaximum;
 
-//    std::cerr << "TimeValueLayer::getDisplayExtents: min = " << min << ", max = " << max << std::endl;
+#ifdef DEBUG_TIME_VALUE_LAYER
+    std::cerr << "TimeValueLayer::getDisplayExtents: min = " << min << ", max = " << max << std::endl;
+#endif
 
     return true;
 }
 
 bool

     }
 
     m_scaleMinimum = min;
     m_scaleMaximum = max;
 
-//    std::cerr << "TimeValueLayer::setDisplayExtents: min = " << min << ", max = " << max << std::endl;
+#ifdef DEBUG_TIME_VALUE_LAYER
+    std::cerr << "TimeValueLayer::setDisplayExtents: min = " << min << ", max = " << max << std::endl;
+#endif
     
     emit layerParametersChanged();
     return true;
 }
 

 
     float dmin, dmax;
     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;
-*/
+#endif
+
     delete mapper;
 
     return 100 - nr;
 }
 

         // see SpectrogramLayer::setVerticalZoomStep
 
         newmax = (newdist + sqrtf(newdist*newdist + 4*dmin*dmax)) / 2;
         newmin = newmax - newdist;
 
-//        std::cerr << "newmin = " << newmin << ", newmax = " << newmax << std::endl;
+#ifdef DEBUG_TIME_VALUE_LAYER
+        std::cerr << "newmin = " << newmin << ", newmax = " << newmax << std::endl;
+#endif
 
     } else {
         float dmid = (dmax + dmin) / 2;
         newmin = dmid - newdist / 2;
         newmax = dmid + newdist / 2;

     }
     if (newmax > max) {
         newmax = max;
     }
     
+#ifdef DEBUG_TIME_VALUE_LAYER
     std::cerr << "TimeValueLayer::setVerticalZoomStep: " << step << ": " << newmin << " -> " << newmax << " (range " << newdist << ")" << std::endl;
+#endif
 
     setDisplayExtents(newmin, newmax);
 }
 
 RangeMapper *

     bool logarithmic = false;
     int h = v->height();
 
     getScaleExtents(v, min, max, logarithmic);
 
-//    std::cerr << "getYForValue(" << val << "): min " << min << ", max "
-//              << max << ", log " << logarithmic << std::endl;
+#ifdef DEBUG_TIME_VALUE_LAYER
+    std::cerr << "getYForValue(" << val << "): min " << min << ", max "
+              << max << ", log " << logarithmic << std::endl;
+#endif
 
     if (logarithmic) {
         val = LogRange::map(val);
     }
 

 
     if (log) {
         val = LogRange::map(val);
     }
 
-//    std::cerr << "TimeValueLayer::getColourForValue: min " << min << ", max "
-//              << max << ", log " << log << ", value " << val << std::endl;
+#ifdef DEBUG_TIME_VALUE_LAYER
+    std::cerr << "TimeValueLayer::getColourForValue: min " << min << ", max "
+              << max << ", log " << log << ", value " << val << std::endl;
+#endif
 
     QColor solid = ColourMapper(m_colourMap, min, max).map(val);
     return QColor(solid.red(), solid.green(), solid.blue(), 120);
 }
 

 
     QColor brushColour(getBaseQColor());
     brushColour.setAlpha(80);
     paint.setBrush(brushColour);
 
-//    std::cerr << "TimeValueLayer::paint: resolution is "
-//	      << m_model->getResolution() << " frames" << std::endl;
+#ifdef DEBUG_TIME_VALUE_LAYER
+    std::cerr << "TimeValueLayer::paint: resolution is "
+	      << m_model->getResolution() << " frames" << std::endl;
+#endif
 
     float min = m_model->getValueMinimum();
     float max = m_model->getValueMaximum();
     if (max == min) max = min + 1.0;
 

     long illuminateFrame = -1;
 
     if (v->shouldIlluminateLocalFeatures(this, localPos)) {
 	SparseTimeValueModel::PointList localPoints =
 	    getLocalPoints(v, localPos.x());
-//        std::cerr << "TimeValueLayer: " << localPoints.size() << " local points" << std::endl;
+#ifdef DEBUG_TIME_VALUE_LAYER
+        std::cerr << "TimeValueLayer: " << localPoints.size() << " local points" << std::endl;
+#endif
 	if (!localPoints.empty()) illuminateFrame = localPoints.begin()->frame;
     }
 
     int w =
 	v->getXForFrame(frame0 + m_model->getResolution()) -

 	    }
 	}
 
 	if (m_plotStyle == PlotSegmentation) {
 
-//            std::cerr << "drawing rect" << std::endl;
+#ifdef DEBUG_TIME_VALUE_LAYER
+            std::cerr << "drawing rect" << std::endl;
+#endif
 	    
 	    if (nx <= x) continue;
 
             if (illuminateFrame != p.frame) {
                 if (!m_drawSegmentDivisions ||

     if (inc > 0) {
         int prec = trunc(log10f(inc));
         prec -= 1;
         if (prec < 0) dp = -prec;
         round = powf(10.f, prec);
-//        std::cerr << "inc = " << inc << ", round = " << round << std::endl;
+#ifdef DEBUG_TIME_VALUE_LAYER
+        std::cerr << "inc = " << inc << ", round = " << round << std::endl;
+#endif
     }
 
     int prevy = -1;
                 
     for (int i = 0; i < n; ++i) {

             if (i == n-1 &&
                 v->height() < paint.fontMetrics().height() * (n*2)) {
                 if (m_model->getScaleUnits() != "") drawText = false;
             }
             dispval = lrintf(val / round) * round;
-//            std::cerr << "val = " << val << ", dispval = " << dispval << std::endl;
+#ifdef DEBUG_TIME_VALUE_LAYER
+            std::cerr << "val = " << val << ", dispval = " << dispval << std::endl;
+#endif
             if (logarithmic) {
                 y = getYForValue(v, LogRange::unmap(dispval));
             } else {
                 y = getYForValue(v, dispval);
             }                

 }
 
 void
 TimeValueLayer::drawStart(View *v, QMouseEvent *e)
 {
-//    std::cerr << "TimeValueLayer::drawStart(" << e->x() << "," << e->y() << ")" << std::endl;
+#ifdef DEBUG_TIME_VALUE_LAYER
+    std::cerr << "TimeValueLayer::drawStart(" << e->x() << "," << e->y() << ")" << std::endl;
+#endif
 
     if (!m_model) return;
 
     long frame = v->getFrameForX(e->x());
     long resolution = m_model->getResolution();

     SparseTimeValueModel::PointList points = getLocalPoints(v, e->x());
     if (!points.empty()) {
         for (SparseTimeValueModel::PointList::iterator i = points.begin();
              i != points.end(); ++i) {
             if (((i->frame / resolution) * resolution) != frame) {
-//                std::cerr << "ignoring out-of-range frame at " << i->frame << std::endl;
+#ifdef DEBUG_TIME_VALUE_LAYER
+                std::cerr << "ignoring out-of-range frame at " << i->frame << std::endl;
+#endif
                 continue;
             }
             m_editingPoint = *i;
             havePoint = true;
         }

 }
 
 void
 TimeValueLayer::drawDrag(View *v, QMouseEvent *e)
 {
-//    std::cerr << "TimeValueLayer::drawDrag(" << e->x() << "," << e->y() << ")" << std::endl;
+#ifdef DEBUG_TIME_VALUE_LAYER
+    std::cerr << "TimeValueLayer::drawDrag(" << e->x() << "," << e->y() << ")" << std::endl;
+#endif
 
     if (!m_model || !m_editing) return;
 
     long frame = v->getFrameForX(e->x());
     long resolution = m_model->getResolution();

 
     float value = getValueForY(v, e->y());
 
     SparseTimeValueModel::PointList points = getLocalPoints(v, e->x());
 
-//    std::cerr << points.size() << " points" << std::endl;
+#ifdef DEBUG_TIME_VALUE_LAYER
+    std::cerr << points.size() << " points" << std::endl;
+#endif
 
     bool havePoint = false;
 
     if (!points.empty()) {
         for (SparseTimeValueModel::PointList::iterator i = points.begin();
              i != points.end(); ++i) {
             if (i->frame == m_editingPoint.frame &&
                 i->value == m_editingPoint.value) {
-            //    std::cerr << "ignoring current editing point at " << i->frame << ", " << i->value << std::endl;
+#ifdef DEBUG_TIME_VALUE_LAYER
+                std::cerr << "ignoring current editing point at " << i->frame << ", " << i->value << std::endl;
+#endif
                 continue;
             }
             if (((i->frame / resolution) * resolution) != frame) {
-            //    std::cerr << "ignoring out-of-range frame at " << i->frame << std::endl;
+#ifdef DEBUG_TIME_VALUE_LAYER
+                std::cerr << "ignoring out-of-range frame at " << i->frame << std::endl;
+#endif
                 continue;
             }
-        //    std::cerr << "adjusting to new point at " << i->frame << ", " << i->value << std::endl;
+#ifdef DEBUG_TIME_VALUE_LAYER
+            std::cerr << "adjusting to new point at " << i->frame << ", " << i->value << std::endl;
+#endif
             m_editingPoint = *i;
             m_originalPoint = m_editingPoint;
             m_editingCommand->deletePoint(m_editingPoint);
             havePoint = true;
         }

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

 }
 
 void
 TimeValueLayer::editStart(View *v, QMouseEvent *e)
 {
-//    std::cerr << "TimeValueLayer::editStart(" << e->x() << "," << e->y() << ")" << std::endl;
+#ifdef DEBUG_TIME_VALUE_LAYER
+    std::cerr << "TimeValueLayer::editStart(" << e->x() << "," << e->y() << ")" << std::endl;
+#endif
 
     if (!m_model) return;
 
     SparseTimeValueModel::PointList points = getLocalPoints(v, e->x());
     if (points.empty()) return;

 }
 
 void
 TimeValueLayer::editDrag(View *v, QMouseEvent *e)
 {
-//    std::cerr << "TimeValueLayer::editDrag(" << e->x() << "," << e->y() << ")" << std::endl;
+#ifdef DEBUG_TIME_VALUE_LAYER
+    std::cerr << "TimeValueLayer::editDrag(" << e->x() << "," << e->y() << ")" << std::endl;
+#endif
 
     if (!m_model || !m_editing) return;
 
     long frame = v->getFrameForX(e->x());
     if (frame < 0) frame = 0;

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

         SparseTimeValueModel::Point formerPrevPoint = prevPoint;
 
         if (i->haveValue()) {
             newPoint.value = i->getValue();
         } else {
-//            std::cerr << "Setting value on point at " << newPoint.frame << " from labeller";
-//            if (i == points.begin()) {
-//                std::cerr << ", no prev point" << std::endl;
-//            } else {
-//                std::cerr << ", prev point is at " << prevPoint.frame << std::endl;
-//            }
+#ifdef DEBUG_TIME_VALUE_LAYER
+            std::cerr << "Setting value on point at " << newPoint.frame << " from labeller";
+            if (i == points.begin()) {
+                std::cerr << ", no prev point" << std::endl;
+            } else {
+                std::cerr << ", prev point is at " << prevPoint.frame << std::endl;
+            }
+#endif
             labeller.setValue<SparseTimeValueModel::Point>
                 (newPoint, (i == points.begin()) ? 0 : &prevPoint);
-//            std::cerr << "New point value = " << newPoint.value << std::endl;
+#ifdef DEBUG_TIME_VALUE_LAYER
+            std::cerr << "New point value = " << newPoint.value << std::endl;
+#endif
             if (labeller.actingOnPrevPoint() && i != points.begin()) {
                 usePrev = true;
             }
         }
 

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