src/Renderer/ChartRenderer.cpp

   1 /*
   2 Copyright_License {
   3
   4   XCSoar Glide Computer - http://www.xcsoar.org/
   5   Copyright (C) 2000-2013 The XCSoar Project
   6   A detailed list of copyright holders can be found in the file "AUTHORS".
   7
   8   This program is free software; you can redistribute it and/or
   9   modify it under the terms of the GNU General Public License
  10   as published by the Free Software Foundation; either version 2
  11   of the License, or (at your option) any later version.
  12
  13   This program is distributed in the hope that it will be useful,
  14   but WITHOUT ANY WARRANTY; without even the implied warranty of
  15   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16   GNU General Public License for more details.
  17
  18   You should have received a copy of the GNU General Public License
  19   along with this program; if not, write to the Free Software
  20   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  21 }
  22 */
  23
  24 #include "ChartRenderer.hpp"
  25 #include "Screen/Canvas.hpp"
  26 #include "Screen/Layout.hpp"
  27 #include "Language/Language.hpp"
  28 #include "Asset.hpp"
  29 #include "Math/LeastSquares.hpp"
  30 #include "Util/StaticString.hpp"
  31
  32 #include <assert.h>
  33 #include <stdio.h>
  34 #include <windef.h> /* for MAX_PATH */
  35
  36 void
  37 ChartRenderer::Axis::Reset()
  38 {
  39   unscaled = true;
  40   scale = fixed(0);
  41   min = fixed(0);
  42   max = fixed(0);
  43 }
  44
  45 PixelScalar
  46 ChartRenderer::Axis::ToScreen(fixed value) const
  47 {
  48   return (long)((value - min) * scale);
  49 }
  50
  51 void
  52 ChartRenderer::ResetScale()
  53 {
  54   x.Reset();
  55   y.Reset();
  56 }
  57
  58 ChartRenderer::ChartRenderer(const ChartLook &_look, Canvas &the_canvas,
  59                              const PixelRect the_rc)
  60   :look(_look), canvas(the_canvas), rc(the_rc),
  61    padding_left(24), padding_bottom(19)
  62 {
  63   ResetScale();
  64 }
  65
  66 void
  67 ChartRenderer::ScaleYFromData(const LeastSquares &lsdata)
  68 {
  69   if (lsdata.IsEmpty())
  70     return;
  71
  72   if (y.unscaled) {
  73     y.min = lsdata.y_min;
  74     y.max = lsdata.y_max;
  75     y.unscaled = false;
  76   } else {
  77     y.min = std::min(y.min, lsdata.y_min);
  78     y.max = std::max(y.max, lsdata.y_max);
  79   }
  80
  81   if (lsdata.sum_n > 1) {
  82     fixed y0, y1;
  83     y0 = lsdata.x_min * lsdata.m + lsdata.b;
  84     y1 = lsdata.x_max * lsdata.m + lsdata.b;
  85     y.min = std::min({y.min, y0, y1});
  86     y.max = std::max({y.max, y0, y1});
  87   }
  88
  89   if (fabs(y.max - y.min) > fixed(50)) {
  90     y.scale = (y.max - y.min);
  91     if (positive(y.scale))
  92       y.scale = fixed(rc.bottom - rc.top - padding_bottom) / y.scale;
  93   } else {
  94     y.scale = fixed(2000);
  95   }
  96 }
  97
  98 void
  99 ChartRenderer::ScaleXFromData(const LeastSquares &lsdata)
 100 {
 101   if (lsdata.IsEmpty())
 102     return;
 103
 104   if (x.unscaled) {
 105     x.min = lsdata.x_min;
 106     x.max = lsdata.x_max;
 107     x.unscaled = false;
 108   } else {
 109     x.min = std::min(x.min, lsdata.x_min);
 110     x.max = std::max(x.max, lsdata.x_max);
 111   }
 112
 113   x.scale = (x.max - x.min);
 114   if (positive(x.scale))
 115     x.scale = fixed(rc.right - rc.left - padding_left) / x.scale;
 116 }
 117
 118 void
 119 ChartRenderer::ScaleYFromValue(const fixed value)
 120 {
 121   if (y.unscaled) {
 122     y.min = value;
 123     y.max = value;
 124     y.unscaled = false;
 125   } else {
 126     y.min = std::min(value, y.min);
 127     y.max = std::max(value, y.max);
 128   }
 129
 130   y.scale = (y.max - y.min);
 131   if (positive(y.scale))
 132     y.scale = fixed(rc.bottom - rc.top - padding_bottom) / y.scale;
 133 }
 134
 135 void
 136 ChartRenderer::ScaleXFromValue(const fixed value)
 137 {
 138   if (x.unscaled) {
 139     x.min = value;
 140     x.max = value;
 141     x.unscaled = false;
 142   } else {
 143     x.min = std::min(value, x.min);
 144     x.max = std::max(value, x.max);
 145   }
 146
 147   x.scale = (x.max - x.min);
 148   if (positive(x.scale))
 149     x.scale = fixed(rc.right - rc.left - padding_left) / x.scale;
 150 }
 151
 152 void
 153 ChartRenderer::DrawLabel(const TCHAR *text, const fixed xv, const fixed yv)
 154 {
 155   canvas.Select(look.label_font);
 156   canvas.SetBackgroundTransparent();
 157
 158   PixelSize tsize = canvas.CalcTextSize(text);
 159   RasterPoint pt = ToScreen(xv, yv);
 160   canvas.DrawText(pt.x - tsize.cx / 2, pt.y - tsize.cy / 2, text);
 161 }
 162
 163 void
 164 ChartRenderer::DrawNoData()
 165 {
 166   canvas.Select(look.label_font);
 167   canvas.SetBackgroundTransparent();
 168
 169   const TCHAR *text = _("No data");
 170   PixelSize tsize = canvas.CalcTextSize(text);
 171
 172   PixelScalar x = (rc.left + rc.right - tsize.cx) / 2;
 173   PixelScalar y = (rc.top + rc.bottom - tsize.cy) / 2;
 174
 175   canvas.DrawText(x, y, text);
 176 }
 177
 178 void
 179 ChartRenderer::DrawXLabel(const TCHAR *text)
 180 {
 181   canvas.Select(look.axis_label_font);
 182   canvas.SetBackgroundTransparent();
 183
 184   PixelSize tsize = canvas.CalcTextSize(text);
 185   PixelScalar x = rc.right - tsize.cx - Layout::Scale(3);
 186   PixelScalar y = rc.bottom - tsize.cy;
 187
 188   canvas.DrawText(x, y, text);
 189 }
 190
 191 void
 192 ChartRenderer::DrawXLabel(const TCHAR *text, const TCHAR *unit)
 193 {
 194   assert(text != NULL);
 195   assert(unit != NULL);
 196
 197   StaticString<64> buffer;
 198   buffer.UnsafeFormat(_T("%s [%s]"), text, unit);
 199   DrawXLabel(buffer);
 200 }
 201
 202 void
 203 ChartRenderer::DrawYLabel(const TCHAR *text)
 204 {
 205   canvas.Select(look.axis_label_font);
 206   canvas.SetBackgroundTransparent();
 207
 208   PixelSize tsize = canvas.CalcTextSize(text);
 209   PixelScalar x = std::max(PixelScalar(2), PixelScalar(rc.left - tsize.cx));
 210   PixelScalar y = rc.top;
 211
 212   canvas.DrawText(x, y, text);
 213 }
 214
 215 void
 216 ChartRenderer::DrawYLabel(const TCHAR *text, const TCHAR *unit)
 217 {
 218   assert(text != NULL);
 219   assert(unit != NULL);
 220
 221   StaticString<64> buffer;
 222   buffer.UnsafeFormat(_T("%s [%s]"), text, unit);
 223   DrawYLabel(buffer);
 224 }
 225
 226 void
 227 ChartRenderer::DrawTrend(const LeastSquares &lsdata, ChartLook::Style style)
 228 {
 229   if (lsdata.sum_n < 2)
 230     return;
 231
 232   if (x.unscaled || y.unscaled)
 233     return;
 234
 235   fixed xmin, xmax, ymin, ymax;
 236   xmin = lsdata.x_min;
 237   xmax = lsdata.x_max;
 238   ymin = lsdata.x_min * lsdata.m + lsdata.b;
 239   ymax = lsdata.x_max * lsdata.m + lsdata.b;
 240
 241   DrawLine(xmin, ymin, xmax, ymax, look.GetPen(style));
 242 }
 243
 244 void
 245 ChartRenderer::DrawTrendN(const LeastSquares &lsdata, ChartLook::Style style)
 246 {
 247   if (lsdata.sum_n < 2)
 248     return;
 249
 250   if (x.unscaled || y.unscaled)
 251     return;
 252
 253   fixed xmin, xmax, ymin, ymax;
 254   xmin = fixed(0.5);
 255   xmax = fixed(lsdata.sum_n) + fixed(0.5);
 256   ymin = lsdata.x_min * lsdata.m + lsdata.b;
 257   ymax = lsdata.x_max * lsdata.m + lsdata.b;
 258
 259   DrawLine(xmin, ymin, xmax, ymax, look.GetPen(style));
 260 }
 261
 262 void
 263 ChartRenderer::DrawLine(const fixed xmin, const fixed ymin,
 264                         const fixed xmax, const fixed ymax, const Pen &pen)
 265 {
 266   if (x.unscaled || y.unscaled)
 267     return;
 268
 269   assert(pen.IsDefined());
 270   canvas.Select(pen);
 271   canvas.DrawLine(ToScreen(xmin, ymin), ToScreen(xmax, ymax));
 272 }
 273
 274 void
 275 ChartRenderer::DrawFilledLine(const fixed xmin, const fixed ymin,
 276                               const fixed xmax, const fixed ymax,
 277                               const Brush &brush)
 278 {
 279   RasterPoint line[4];
 280
 281   line[0] = ToScreen(xmin, ymin);
 282   line[1] = ToScreen(xmax, ymax);
 283
 284   line[2].x = line[1].x;
 285   line[2].y = ScreenY(fixed(0));
 286   line[3].x = line[0].x;
 287   line[3].y = line[2].y;
 288
 289   canvas.Select(brush);
 290   canvas.SelectNullPen();
 291   canvas.DrawTriangleFan(line, 4);
 292 }
 293
 294 void
 295 ChartRenderer::DrawLine(const fixed xmin, const fixed ymin,
 296                         const fixed xmax, const fixed ymax,
 297                         ChartLook::Style style)
 298 {
 299   DrawLine(xmin, ymin, xmax, ymax, look.GetPen(style));
 300 }
 301
 302 void
 303 ChartRenderer::DrawBarChart(const LeastSquares &lsdata)
 304 {
 305   if (x.unscaled || y.unscaled)
 306     return;
 307
 308   canvas.Select(look.bar_brush);
 309   canvas.SelectNullPen();
 310
 311   for (unsigned i = 0, n = lsdata.slots.size(); i != n; i++) {
 312     PixelScalar xmin((fixed(i) + fixed(1.2)) * x.scale
 313                      + fixed(rc.left + padding_left));
 314     PixelScalar ymin = ScreenY(y.min);
 315     PixelScalar xmax((fixed(i) + fixed(1.8)) * x.scale
 316                      + fixed(rc.left + padding_left));
 317     PixelScalar ymax = ScreenY(lsdata.slots[i].y);
 318     canvas.Rectangle(xmin, ymin, xmax, ymax);
 319   }
 320 }
 321
 322 void
 323 ChartRenderer::DrawFilledLineGraph(const LeastSquares &lsdata)
 324 {
 325   assert(lsdata.slots.size() >= 2);
 326
 327   const unsigned n = lsdata.slots.size() + 2;
 328   RasterPoint *points = point_buffer.get(n);
 329
 330   RasterPoint *p = points;
 331   for (auto i = lsdata.slots.begin(), end = lsdata.slots.end();
 332        i != end; ++i)
 333     *p++ = ToScreen(i->x, i->y);
 334   const RasterPoint &last = p[-1];
 335   *p++ = RasterPoint{ last.x, rc.bottom - padding_bottom };
 336   *p++ = RasterPoint{ points[0].x, rc.bottom - padding_bottom };
 337
 338   assert(p == points + n);
 339
 340   canvas.DrawPolygon(points, n);
 341 }
 342
 343 void
 344 ChartRenderer::DrawLineGraph(const LeastSquares &lsdata, const Pen &pen)
 345 {
 346   assert(lsdata.slots.size() >= 2);
 347
 348   const unsigned n = lsdata.slots.size();
 349   RasterPoint *points = point_buffer.get(n);
 350
 351   RasterPoint *p = points;
 352   for (auto i = lsdata.slots.begin(), end = lsdata.slots.end();
 353        i != end; ++i)
 354     *p++ = ToScreen(i->x, i->y);
 355   assert(p == points + n);
 356
 357   canvas.Select(pen);
 358   canvas.DrawPolyline(points, n);
 359 }
 360
 361 void
 362 ChartRenderer::DrawLineGraph(const LeastSquares &lsdata,
 363                              ChartLook::Style style)
 364 {
 365   DrawLineGraph(lsdata, look.GetPen(style));
 366 }
 367
 368 void
 369 ChartRenderer::FormatTicText(TCHAR *text, const fixed val, const fixed step)
 370 {
 371   if (step < fixed(1)) {
 372     _stprintf(text, _T("%.1f"), (double)val);
 373   } else {
 374     _stprintf(text, _T("%.0f"), (double)val);
 375   }
 376 }
 377
 378 void
 379 ChartRenderer::DrawXGrid(const fixed tic_step, ChartLook::Style style,
 380                          const fixed unit_step, bool draw_units)
 381 {
 382   DrawXGrid(tic_step, look.GetPen(style), unit_step, draw_units);
 383 }
 384
 385 void
 386 ChartRenderer::DrawXGrid(fixed tic_step, const Pen &pen,
 387                          fixed unit_step, bool draw_units)
 388 {
 389   assert(positive(tic_step));
 390
 391   canvas.Select(pen);
 392   canvas.Select(look.axis_value_font);
 393   canvas.SetBackgroundTransparent();
 394
 395   RasterPoint line[2];
 396
 397   /** the minimum next position of the text, to avoid overlapping */
 398   PixelScalar next_text = rc.left;
 399
 400   /* increase tic step so graph not too crowded */
 401   while ((x.max-x.min)/tic_step > fixed(10)) {
 402     tic_step *= fixed(2);
 403     unit_step *= fixed(2);
 404   }
 405   //  bool do_units = ((x.max-zero)/tic_step)<10;
 406
 407   line[0].y = rc.top;
 408   line[1].y = rc.bottom - padding_bottom;
 409
 410   fixed start = (int)(x.min / tic_step) * tic_step;
 411
 412   for (fixed xval = start; xval <= x.max; xval += tic_step) {
 413     const PixelScalar xmin = ScreenX(xval);
 414     line[0].x = line[1].x = xmin;
 415
 416     // STYLE_THINDASHPAPER
 417     if (xmin >= rc.left + padding_left && xmin <= rc.right) {
 418       canvas.DrawLine(line[0], line[1]);
 419
 420       if (draw_units && xmin >= next_text) {
 421         TCHAR unit_text[MAX_PATH];
 422         FormatTicText(unit_text, xval * unit_step / tic_step, unit_step);
 423
 424         canvas.DrawText(xmin, rc.bottom - Layout::Scale(17), unit_text);
 425
 426         next_text = xmin + canvas.CalcTextSize(unit_text).cx + Layout::FastScale(2);
 427       }
 428     }
 429   }
 430 }
 431
 432 void
 433 ChartRenderer::DrawYGrid(const fixed tic_step, ChartLook::Style style,
 434                          const fixed unit_step, bool draw_units)
 435 {
 436   DrawYGrid(tic_step, look.GetPen(style), unit_step, draw_units);
 437 }
 438
 439 void
 440 ChartRenderer::DrawYGrid(fixed tic_step, const Pen &pen,
 441                          fixed unit_step, bool draw_units)
 442 {
 443   assert(positive(tic_step));
 444
 445   canvas.Select(pen);
 446   canvas.Select(look.axis_value_font);
 447   canvas.SetBackgroundTransparent();
 448
 449   RasterPoint line[2];
 450
 451   /* increase tic step so graph not too crowded */
 452   while ((y.max-y.min)/tic_step > fixed(10)) {
 453     tic_step *= fixed(2);
 454     unit_step *= fixed(2);
 455   }
 456
 457   line[0].x = rc.left + padding_left;
 458   line[1].x = rc.right;
 459
 460   fixed start = (int)(y.min / tic_step) * tic_step;
 461
 462   for (fixed yval = start; yval <= y.max; yval += tic_step) {
 463     const PixelScalar ymin = ScreenY(yval);
 464     line[0].y = line[1].y = ymin;
 465
 466     // STYLE_THINDASHPAPER
 467     if (ymin >= rc.top && ymin <= rc.bottom - padding_bottom) {
 468       canvas.DrawLine(line[0], line[1]);
 469
 470       if (draw_units) {
 471         TCHAR unit_text[MAX_PATH];
 472         FormatTicText(unit_text, yval * unit_step / tic_step, unit_step);
 473
 474         canvas.DrawText(rc.left + Layout::Scale(8), ymin, unit_text);
 475       }
 476     }
 477   }
 478 }
 479
 480 PixelScalar
 481 ChartRenderer::ScreenX(fixed _x) const
 482 {
 483   return rc.left + padding_left + x.ToScreen(_x);
 484 }
 485
 486 PixelScalar
 487 ChartRenderer::ScreenY(fixed _y) const
 488 {
 489   return rc.bottom - padding_bottom - y.ToScreen(_y);
 490 }
 491
 492 void
 493 ChartRenderer::DrawFilledY(const std::vector<std::pair<fixed, fixed>> &vals,
 494                            const Brush &brush, const Pen* pen)
 495 {
 496   if (vals.size()<2)
 497     return;
 498   const unsigned fsize = vals.size()+2;
 499   RasterPoint *line = point_buffer.get(fsize);
 500
 501   for (unsigned i = 0; i < vals.size(); ++i)
 502     line[i + 2] = ToScreen(vals[i].first, vals[i].second);
 503
 504   line[0].x = rc.left + padding_left;
 505   line[0].y = line[fsize-1].y;
 506   line[1].x = rc.left + padding_left;
 507   line[1].y = line[2].y;
 508
 509   canvas.Select(brush);
 510   if (pen == NULL) {
 511     canvas.SelectNullPen();
 512   } else {
 513     canvas.Select(*pen);
 514   }
 515   canvas.DrawPolygon(line, fsize);
 516 }
 517
 518 void
 519 ChartRenderer::DrawDot(const fixed x, const fixed y, const PixelScalar width)
 520 {
 521   RasterPoint p = ToScreen(x, y);
 522   RasterPoint line[4] = { { p.x, p.y - width },
 523                           { p.x - width, p.y },
 524                           { p.x, p.y + width },
 525                           { p.x + width, p.y } };
 526   canvas.SelectNullPen();
 527   canvas.DrawTriangleFan(line, 4);
 528 }