source: flair-src/trunk/tools/FlairGCS/src/DataPlot2D.cpp@ 468

// %flair:license{
// This file is part of the Flair framework distributed under the
// CECILL-C License, Version 1.0.
// %flair:license}
#include "DataPlot2D.h"
#include "Layout.h"
#include <qwt_plot.h>
#include <qwt_plot_curve.h>
#include <qwt_plot_grid.h>
#include <qwt_plot_magnifier.h>
#include <qwt_plot_canvas.h>
#include <qwt_scale_widget.h>
#include <qwt_legend_label.h>
#include <qwt_legend.h>
#include <qwt_plot_panner.h>
#include <qwt_plot_rescaler.h>
#include <QMouseEvent>
#include <QMenu>
#include <QInputDialog>
#include <qendian.h>

DataPlot2D::DataPlot2D(Layout *parent, int row, int col, QString plot_name,
                       QString x_name, QString y_name, float xmin, float xmax,
                       float ymin, float ymax, bool enabled, uint16_t period, uint16_t nb_buffering)
    : DataRemote(plot_name, "DataPlot2D", parent, enabled, period, nb_buffering) {
  plot = new QwtPlot(NULL);
  plot->setEnabled(enabled);

  parent->addWidget(plot, row, col);
  visible_widget = plot;

  view_size = 20; // default 20s
                  /*
                      // Disable polygon clipping
                      QwtPainter::setDeviceClipping(false);
                  
                      // We don't need the cache here
                      plot->canvas()->setPaintAttribute(QwtPlotCanvas::PaintCached, false);
                      plot->canvas()->setPaintAttribute(QwtPlotCanvas::PaintPacked, false);
                  */
#if QT_VERSION >= 0x040000
#ifdef Q_WS_X11
  /*
     Qt::WA_PaintOnScreen is only supported for X11, but leads
     to substantial bugs with Qt 4.2.x/Windows
   */
  plot->canvas()->setAttribute(Qt::WA_PaintOnScreen, true);
#endif
#endif

  alignScales();

  datas = new QList<QwtPlotCurve *>;
  datas_type = new QList<QString>;

  // Assign a title
  plot->setTitle(plot_name);

  // Axis
  plot->setAxisTitle(QwtPlot::xBottom, x_name);
  setXAxisScale(xmin, xmax);

  plot->setAxisTitle(QwtPlot::yLeft, y_name);
  setYAxisScale(ymin, ymax);

  QwtPlotRescaler *rescaler = new QwtPlotRescaler(plot->canvas());
  rescaler->setRescalePolicy(QwtPlotRescaler::Fixed); /*
 rescaler->setReferenceAxis(QwtPlot::xBottom);
 rescaler->setAspectRatio(QwtPlot::yLeft, 1.0);*/

  // grid
  QwtPlotGrid *grid = new QwtPlotGrid;
  // grid->enableXMin(false);
  grid->setPen(QPen(Qt::black, 0, Qt::DotLine));
  // grid->setMinPen(QPen(Qt::gray, 0 , Qt::DotLine));
  grid->attach(plot);

  // zoomer
  QwtPlotMagnifier *zoomer = new QwtPlotMagnifier(plot->canvas());
  zoomer->setMouseButton(Qt::RightButton, Qt::ControlModifier);

  // scroller
  QwtPlotPanner *scroller = new QwtPlotPanner(plot->canvas());

  // legend
  QwtLegend *new_legend = new QwtLegend();
  new_legend->setDefaultItemMode(QwtLegendData::Checkable);
  plot->insertLegend(new_legend, QwtPlot::BottomLegend);

  connect(new_legend, SIGNAL(checked(const QVariant &, bool, int)),
          SLOT(legendChecked(const QVariant &, bool)));

  plot->canvas()->installEventFilter(this);
}

DataPlot2D::~DataPlot2D() {
  for (int i = 0; i < d_x.count(); i++) {
    free(d_x.at(i));
    free(d_y.at(i));
  }

  delete datas;
  delete datas_type;
}

void DataPlot2D::XmlEvent(QDomElement *dom) {
  if (dom->attribute("curve") != "") {
    QString type = dom->attribute("type");
    int r = dom->attribute("r").toInt();
    int g = dom->attribute("g").toInt();
    int b = dom->attribute("b").toInt();
    QString name = dom->attribute("curve");
    addCurve(QPen(QColor(r, g, b, 255)), name, type);
  } else {
    double saved_refresh_rate=refresh_rate;
    XmlSetup(dom);
    if(refresh_rate!=saved_refresh_rate) {//copy datas for the new refresh rate with same view size
      double ratio=refresh_rate/saved_refresh_rate;
      for (int i = 0; i < datas->count(); i++) {
          double *bufx =(double *)malloc(view_size / refresh_rate * sizeof(double));
          double *bufy =(double *)malloc(view_size / refresh_rate * sizeof(double));
          for (int j=0;j<(int)(view_size/refresh_rate);j++) {
            bufx[j] = d_x.at(i)[(int)(j*ratio)];
            bufy[j] = d_y.at(i)[(int)(j*ratio)];
          }
          free(d_x[i]);
          d_x[i] = bufx;
          free(d_y[i]);
          d_y[i] = bufy;
          datas->at(i)->setRawSamples(d_x.at(i), d_y.at(i), view_size / refresh_rate);
      }
    }
    plot->setEnabled(IsEnabled());
  }
}

bool DataPlot2D::eventFilter(QObject *o, QEvent *e) {
  if (o == plot->canvas()) {
    switch (e->type()) {
    case QEvent::MouseButtonPress: {
      mousePressEvent((QMouseEvent *)e);
      break;
    }

    default:
      break;
    }
  }
  return plot->eventFilter(o, e);
}

void DataPlot2D::legendChecked(const QVariant &itemInfo, bool on) {
  QwtPlotItem *plotItem = plot->infoToItem(itemInfo);
  if (plotItem)
    showCurve(plotItem, on);
}

void DataPlot2D::showCurve(QwtPlotItem *item, bool on) {
  item->setVisible(on);

  QwtLegend *lgd = qobject_cast<QwtLegend *>(plot->legend());

  QList<QWidget *> legendWidgets = lgd->legendWidgets(plot->itemToInfo(item));

  if (legendWidgets.size() == 1) {
    QwtLegendLabel *legendLabel =
        qobject_cast<QwtLegendLabel *>(legendWidgets[0]);

    if (legendLabel)
      legendLabel->setChecked(on);
  }

  plot->replot();
}

void DataPlot2D::addCurve(QPen pen, QString legend, QString type) {
  double *new_dx;
  new_dx = (double *)malloc(view_size / refresh_rate * sizeof(double));
  d_x.append(new_dx);
  double *new_dy;
  new_dy = (double *)malloc(view_size / refresh_rate * sizeof(double));
  d_y.append(new_dy);

  //  Initialize data
  for (int i = 0; i < view_size / refresh_rate; i++)
    new_dx[i] = 0;
  for (int i = 0; i < view_size / refresh_rate; i++)
    new_dy[i] = 0;

  // Insert new curve
  QwtPlotCurve *new_data;

  new_data = new QwtPlotCurve(legend);
  new_data->attach(plot);
  new_data->setPen(pen);
  datas->append(new_data);

  showCurve(new_data, true);

  datas_type->append(type);
  bool tmp = true;
  datas_first_update.append(tmp);

  // Attach (don't copy) data. Both curves use the same x array.
  new_data->setRawSamples(new_dx, new_dy, view_size / refresh_rate);

  if (type == "float") {
    receivesize += sizeof(float);
  } else if (type == "int8_t") {
    receivesize += sizeof(int8_t);
  } else if (type == "int16_t") {
    receivesize += sizeof(int16_t);
  } else {
    fprintf(stderr,"DataPlot2D::addCurve unknown type %s\n",
           type.toLocal8Bit().constData());
  }
}

void DataPlot2D::setXAxisScale(float xmin, float xmax) {
  xmin_orig = xmin;
  xmax_orig = xmax;
  plot->setAxisScale(QwtPlot::xBottom, xmin_orig, xmax_orig);
}

void DataPlot2D::setYAxisScale(float ymin, float ymax) {
  ymin_orig = ymin;
  ymax_orig = ymax;
  plot->setAxisScale(QwtPlot::yLeft, ymin_orig, ymax_orig);
}

//
//  Set a plain canvas frame and align the scales to it
//
void DataPlot2D::alignScales(void) {
  // The code below shows how to align the scales to
  // the canvas frame, but is also a good example demonstrating
  // why the spreaded API needs polishing.
  /*
      plot->canvas()->setFrameStyle(QFrame::Box | QFrame::Plain );
      plot->canvas()->setLineWidth(1);
  */
  for (int i = 0; i < QwtPlot::axisCnt; i++) {
    QwtScaleWidget *scaleWidget = (QwtScaleWidget *)plot->axisWidget(i);
    if (scaleWidget)
      scaleWidget->setMargin(0);

    QwtScaleDraw *scaleDraw = (QwtScaleDraw *)plot->axisScaleDraw(i);
    if (scaleDraw)
      scaleDraw->enableComponent(QwtAbstractScaleDraw::Backbone, false);
  }
}

void DataPlot2D::BufEvent(char **buf, int *buf_size, uint16_t period,uint16_t nb_buffering,bool big_endian) {
  
  if (IsEnabled() == false || RefreshRate_ms() != period || NbBuffering()!=nb_buffering) return;

  for (int i = 0; i < datas->count(); i++) {
    if (datas_type->at(i) == "float") {
      uint32_t data1_raw;
      float *data1 = (float *)&data1_raw;
      uint32_t data2_raw;
      float *data2 = (float *)&data2_raw;

      memcpy((void *)&data1_raw, *buf, sizeof(uint32_t));
      *buf += sizeof(uint32_t);
      memcpy((void *)&data2_raw, *buf, sizeof(uint32_t));
      *buf += sizeof(uint32_t);
      if (big_endian == true)
        data1_raw = qFromBigEndian(data1_raw);
      if (big_endian == true)
        data2_raw = qFromBigEndian(data2_raw);
      plot_data(*data1, *data2, i);
    } else if (datas_type->at(i) == "int8_t") {
      int8_t data1, data2;
      memcpy((void *)&data1, *buf, sizeof(data1));
      *buf += sizeof(data1);
      memcpy((void *)&data2, *buf, sizeof(data2));
      *buf += sizeof(data2);
      plot_data(data1, data2, i);
    } else if (datas_type->at(i) == "int16_t") {
      int16_t data1, data2;
      memcpy((void *)&data1, *buf, sizeof(data1));
      *buf += sizeof(data1);
      memcpy((void *)&data2, *buf, sizeof(data2));
      *buf += sizeof(data2);
      plot_data(data1, data2, i);
    } else {
      fprintf(stderr,"DataPlot2D::DrawDatas type non connu\n");
    }
  }
  plot->replot();
}

void DataPlot2D::plot_data(double data_x, double data_y, int index) {
  if (index < d_y.count()) {
    if (datas_first_update.at(index) == false) {
      // Shift y array left and assign new value to y[view_size/refresh_rate-1].
      for (int j = 0; j < view_size / refresh_rate - 1; j++)
        d_y.at(index)[j] = d_y.at(index)[j + 1];
      for (int j = 0; j < view_size / refresh_rate - 1; j++)
        d_x.at(index)[j] = d_x.at(index)[j + 1];
      d_y.at(index)[(int)(view_size / refresh_rate) - 1] = data_y;
      d_x.at(index)[(int)(view_size / refresh_rate) - 1] = data_x;
    } else {
      for (int j = 0; j <= view_size / refresh_rate - 1; j++)
        d_y.at(index)[j] = data_y;
      for (int j = 0; j <= view_size / refresh_rate - 1; j++)
        d_x.at(index)[j] = data_x;
      datas_first_update[index] = false;
    }
  }
}

// context menu
void DataPlot2D::mousePressEvent(QMouseEvent *event) {
  if (event->button() == Qt::RightButton) {

    QMenu *menu = new QMenu("nom", plot);
    // ajout des actions
    QAction *reset_zoom, *set_view_size, *action;

    reset_zoom = menu->addAction("reset zoom");
    menu->addSeparator();

    set_view_size = menu->addAction(QString("set view size (%1s)").arg(view_size));

    appendmenu(menu);
    action = execmenu(plot, menu, event->globalPos());
    delete menu;

    if (action == reset_zoom) {
      // zoom to original size
      plot->setAxisScale(QwtPlot::yLeft, ymin_orig, ymax_orig);
      plot->setAxisScale(QwtPlot::xBottom, xmin_orig, xmax_orig);
    }

    if (action == set_view_size) {
      bool ok;
      float new_view_size = QInputDialog::getInt(
          plot, QString("Set view size (%1)").arg(plot->title().text()),
          tr("Value (s):"), view_size, 1, 65535, 10, &ok);
      if (ok == true) {
        for (int i = 0; i < datas->count(); i++) {
          if (new_view_size > view_size) {//get last samples and expand
            double *buf =(double *)malloc(new_view_size / refresh_rate * sizeof(double));
            memcpy(&buf[(int)(new_view_size / refresh_rate)-(int)(view_size / refresh_rate)], d_x[i], (view_size / refresh_rate) * sizeof(double));
            free(d_x[i]);
            d_x[i] = buf;
            
            buf =(double *)malloc(new_view_size / refresh_rate * sizeof(double));
            memcpy(&buf[(int)(new_view_size / refresh_rate)-(int)(view_size / refresh_rate)], d_y[i], (view_size / refresh_rate) * sizeof(double));
            free(d_y[i]);
            d_y[i] = buf;
            
            for (int j=0;j<(int)(new_view_size/refresh_rate)-(int)(view_size/refresh_rate);j++) {
              d_x.at(i)[j] = d_x.at(i)[(int)(new_view_size/refresh_rate)-(int)(view_size/refresh_rate)+1];
              d_y.at(i)[j] = d_y.at(i)[(int)(new_view_size/refresh_rate)-(int)(view_size/refresh_rate)+1];
            }
          } else {//get last samples
            double *buf =(double *)malloc(new_view_size / refresh_rate * sizeof(double));
            memcpy(buf, &d_x[i][(int)(view_size / refresh_rate)-(int)(new_view_size / refresh_rate)],(new_view_size / refresh_rate) * sizeof(double));
            free(d_x[i]);
            d_x[i] = buf;
            
            buf =(double *)malloc(new_view_size / refresh_rate * sizeof(double));
            memcpy(buf, &d_y[i][(int)(view_size / refresh_rate) -(int)(new_view_size / refresh_rate)],(new_view_size / refresh_rate) * sizeof(double));
            free(d_y[i]);
            d_y[i] = buf;
          }
          datas->at(i)->setRawSamples(d_x.at(i), d_y.at(i), new_view_size / refresh_rate);
        }
        view_size = new_view_size;
      }
    }
  }
}