src/elevationgraph.cpp

   1 #include <cmath>
   2 #include "config.h"
   3 #include "data.h"
   4 #include "elevationgraph.h"
   5
   6
   7 static qreal nMin(qreal a, qreal b)
   8 {
   9         if (!std::isnan(a) && !std::isnan(b))
  10                 return qMin(a, b);
  11         else if (!std::isnan(a))
  12                 return a;
  13         else if (!std::isnan(b))
  14                 return b;
  15         else
  16                 return NAN;
  17 }
  18
  19 static qreal nMax(qreal a, qreal b)
  20 {
  21         if (!std::isnan(a) && !std::isnan(b))
  22                 return qMax(a, b);
  23         else if (!std::isnan(a))
  24                 return a;
  25         else if (!std::isnan(b))
  26                 return b;
  27         else
  28                 return NAN;
  29 }
  30
  31 ElevationGraph::ElevationGraph(QWidget *parent) : GraphTab(parent)
  32 {
  33         _trackAscent = 0;
  34         _routeAscent = 0;
  35         _trackDescent = 0;
  36         _routeDescent = 0;
  37         _trackMin = NAN;
  38         _trackMax = NAN;
  39         _routeMin = NAN;
  40         _routeMax = NAN;
  41
  42         _showRoutes = true;
  43         _showTracks = true;
  44
  45         _units = Metric;
  46
  47         setYUnits();
  48         setYLabel(tr("Elevation"));
  49
  50         setMinYRange(50.0);
  51 }
  52
  53 void ElevationGraph::setInfo()
  54 {
  55         if (std::isnan(max()) || std::isnan(min()))
  56                 clearInfo();
  57         else {
  58                 GraphView::addInfo(tr("Ascent"), QString::number(ascent() * yScale(),
  59                   'f', 0) + UNIT_SPACE + yUnits());
  60                 GraphView::addInfo(tr("Descent"), QString::number(descent() * yScale(),
  61                   'f', 0) + UNIT_SPACE + yUnits());
  62                 GraphView::addInfo(tr("Maximum"), QString::number(max() * yScale(), 'f',
  63                   0) + UNIT_SPACE + yUnits());
  64                 GraphView::addInfo(tr("Minimum"), QString::number(min() * yScale(), 'f',
  65                   0) + UNIT_SPACE + yUnits());
  66         }
  67 }
  68
  69 void ElevationGraph::loadGraph(const Graph &graph, Type type, PathItem *path)
  70 {
  71         qreal ascent = 0, descent = 0;
  72         qreal min, max;
  73
  74         if (graph.size() < 2) {
  75                 skipColor();
  76                 return;
  77         }
  78
  79         max = min = graph.at(0).y();
  80         for (int j = 1; j < graph.size(); j++) {
  81                 qreal cur = graph.at(j).y();
  82                 qreal prev = graph.at(j-1).y();
  83
  84                 if (cur > prev)
  85                         ascent += cur - prev;
  86                 if (cur < prev)
  87                         descent += prev - cur;
  88
  89                 if (cur < min)
  90                         min = cur;
  91                 if (cur > max)
  92                         max = cur;
  93         }
  94
  95         if (type == Track) {
  96                 _trackAscent += ascent;
  97                 _trackDescent += descent;
  98                 _trackMax = nMax(_trackMax, max);
  99                 _trackMin = nMin(_trackMin, min);
 100         } else {
 101                 _routeAscent += ascent;
 102                 _routeDescent += descent;
 103                 _routeMax = nMax(_routeMax, max);
 104                 _routeMin = nMin(_routeMin, min);
 105         }
 106
 107         GraphView::loadGraph(graph, path, type);
 108 }
 109
 110 void ElevationGraph::loadData(const Data &data, const QList<PathItem *> &paths)
 111 {
 112         int p = 0;
 113
 114         for (int i = 0; i < data.tracks().count(); i++)
 115                 loadGraph(data.tracks().at(i)->elevation(), Track, paths.at(p++));
 116         for (int i = 0; i < data.routes().count(); i++)
 117                 loadGraph(data.routes().at(i)->elevation(), Route, paths.at(p++));
 118
 119         setInfo();
 120
 121         redraw();
 122 }
 123
 124 void ElevationGraph::clear()
 125 {
 126         _trackAscent = 0;
 127         _routeAscent = 0;
 128         _trackDescent = 0;
 129         _routeDescent = 0;
 130         _trackMin = NAN;
 131         _trackMax = NAN;
 132         _routeMin = NAN;
 133         _routeMax = NAN;
 134
 135         GraphView::clear();
 136 }
 137
 138 void ElevationGraph::setYUnits()
 139 {
 140         if (_units == Metric) {
 141                 GraphView::setYUnits(tr("m"));
 142                 setYScale(1);
 143         } else {
 144                 GraphView::setYUnits(tr("ft"));
 145                 setYScale(M2FT);
 146         }
 147 }
 148
 149 void ElevationGraph::setUnits(enum Units units)
 150 {
 151         _units = units;
 152
 153         setYUnits();
 154         setInfo();
 155         GraphView::setUnits(units);
 156
 157         redraw();
 158 }
 159
 160 void ElevationGraph::showTracks(bool show)
 161 {
 162         _showTracks = show;
 163
 164         setInfo();
 165         showGraph(show, Track);
 166
 167         redraw();
 168 }
 169
 170 void ElevationGraph::showRoutes(bool show)
 171 {
 172         _showRoutes = show;
 173
 174         showGraph(show, Route);
 175         setInfo();
 176
 177         redraw();
 178 }
 179
 180 qreal ElevationGraph::ascent() const
 181 {
 182         qreal val = 0;
 183
 184         if (_showRoutes)
 185                 val += _routeAscent;
 186         if (_showTracks)
 187                 val += _trackAscent;
 188
 189         return val;
 190 }
 191
 192 qreal ElevationGraph::descent() const
 193 {
 194         qreal val = 0;
 195
 196         if (_showRoutes)
 197                 val += _routeDescent;
 198         if (_showTracks)
 199                 val += _trackDescent;
 200
 201         return val;
 202 }
 203
 204 qreal ElevationGraph::max() const
 205 {
 206         qreal val;
 207
 208         if (_showRoutes && _showTracks)
 209                 val = nMax(_routeMax, _trackMax);
 210         else if (_showTracks)
 211                 val = _trackMax;
 212         else if (_showRoutes)
 213                 val = _routeMax;
 214         else
 215                 val = NAN;
 216
 217         return val;
 218 }
 219
 220 qreal ElevationGraph::min() const
 221 {
 222         qreal val;
 223
 224         if (_showRoutes && _showTracks)
 225                 val = nMin(_routeMin, _trackMin);
 226         else if (_showTracks)
 227                 val = _trackMin;
 228         else if (_showRoutes)
 229                 val = _routeMin;
 230         else
 231                 val = NAN;
 232
 233         return val;
 234 }