PlotCurve.cpp

#include "IsisDebug.h"
 
#include "PlotCurve.h"
 
#include <iostream>
 
#include <qwt_plot.h>
#include <qwt_plot_curve.h>
#include <qwt_plot_marker.h>
#include <qwt_symbol.h>
 
#include <QBuffer>
#include <QByteArray>
 
#include "SpecialPixel.h"
 
namespace Isis {
  PlotCurve::PlotCurve(Units xUnits, Units yUnits)  : QwtPlotCurve() {
    m_markerSymbol = new QwtSymbol();
    m_markerSymbol->setStyle(QwtSymbol::NoSymbol);
    m_markerSymbol->setSize(6, 6);
    m_color = QColor(Qt::white);
    m_xUnits = xUnits;
    m_yUnits = yUnits;
  }
 
 
  PlotCurve::~PlotCurve() {
    if (plot()) {
      clearMarkers();
    }
  }
 
 
  void PlotCurve::attachMarkers() {
    recreateMarkers();
  }
 
 
  QColor PlotCurve::color() const {
    return m_color;
  }
 
 
  QwtSymbol *PlotCurve::markerSymbol() const {
    return m_markerSymbol;
  }
 
 
  PlotCurve::Units PlotCurve::xUnits() const {
    return m_xUnits;
  }
 
 
  PlotCurve::Units PlotCurve::yUnits() const {
    return m_yUnits;
  }
 
 
  void PlotCurve::setColor(const QColor &color) {
    //set the data for the curve
    m_color = color;
    setPen(pen());
  }
 
 
  void PlotCurve::setData(QwtSeriesData<QPointF> *data) {
    //set the data for the curve
    QwtPlotCurve::setData(data);
    recreateMarkers();
  }
 
 
  void PlotCurve::setMarkerSymbol(QwtSymbol::Style style) {
    m_markerSymbol->setStyle(style);
    recreateMarkers();
  }
 
 
  void PlotCurve::setMarkerVisible(bool visible) {
    foreach (QwtPlotMarker *marker, m_valuePointMarkers) {
      marker->setVisible(visible);
    }
  }
 
 
 
  QByteArray PlotCurve::fromByteArray(const QByteArray &classData) {
    QString expectedHeader("PLOT_CURVE_V1");
    int headerKeySize = expectedHeader.toUtf8().size();
 
    if (classData.size() > headerKeySize) {
      int dataPos = 0;
      const char *rawClassData = classData.data();
 
      QString givenKey = QString::fromUtf8(classData.data() + dataPos,
                                           headerKeySize);
      dataPos += headerKeySize;
      if (givenKey != expectedHeader) {
        IString msg = "The given byte array does not contain the required "
            "header";
        throw IException(IException::Programmer, msg, _FILEINFO_);
      }
 
      int titleSize = *(((int *)(rawClassData + dataPos)));
      dataPos += sizeof(int);
 
      setTitle(QString::fromUtf8(classData.data() + dataPos, titleSize));
      dataPos += titleSize;
 
      m_xUnits = (Units)(*((int *)(rawClassData + dataPos)));
      dataPos += sizeof(int);
 
      m_yUnits = (Units)(*((int *)(rawClassData + dataPos)));
      dataPos += sizeof(int);
 
      // Read the pen...
      int penBufferSize = *(((int *)(rawClassData + dataPos)));
      dataPos += sizeof(int);
 
      QByteArray penBufferBytes(rawClassData + dataPos, penBufferSize);
      dataPos += penBufferSize;
 
      QBuffer penDataBuffer(&penBufferBytes);
      penDataBuffer.open(QIODevice::ReadWrite);
 
      QDataStream penDataStream(&penDataBuffer);
      QPen pen;
      penDataStream >> pen;
      setPen(pen);
 
 
      // Read the color...
      int colorBufferSize = *(((int *)(rawClassData + dataPos)));
      dataPos += sizeof(int);
 
      QByteArray colorBufferBytes(rawClassData + dataPos, colorBufferSize);
      dataPos += colorBufferSize;
 
      QBuffer colorDataBuffer(&colorBufferBytes);
      colorDataBuffer.open(QIODevice::ReadWrite);
 
      QDataStream colorDataStream(&colorDataBuffer);
      QColor newColor;
      colorDataStream >> newColor;
      setColor(newColor);
 
      // Read the marker symbol...
      int markerSymbolBufferSize = *(((int *)(rawClassData + dataPos)));
      dataPos += sizeof(int);
 
      QByteArray markerSymbolBufferBytes(rawClassData + dataPos,
                                         markerSymbolBufferSize);
      dataPos += markerSymbolBufferSize;
 
      QBuffer markerSymbolDataBuffer(&markerSymbolBufferBytes);
      markerSymbolDataBuffer.open(QIODevice::ReadWrite);
 
      QDataStream markerSymbolDataStream(&markerSymbolDataBuffer);
 
      QBrush markerBrush;
      markerSymbolDataStream >> markerBrush;
      m_markerSymbol->setBrush(markerBrush);
 
      QPen markerPen;
      markerSymbolDataStream >> markerPen;
      m_markerSymbol->setPen(markerPen);
 
      QSize markerSize;
      markerSymbolDataStream >> markerSize;
      m_markerSymbol->setSize(markerSize);
 
      int markerStyle;
      markerSymbolDataStream >> markerStyle;
      m_markerSymbol->setStyle((QwtSymbol::Style)markerStyle);
 
      // Done reading the more advanced items, finish up with the data
      int plotDataSize = *((int *)(rawClassData + dataPos));
      dataPos += sizeof(int);
      QVector<QPointF> plotDataValues;
 
      for (int i = 0; i < plotDataSize; i ++) {
        double x = *((double *)(rawClassData + dataPos));
        dataPos += sizeof(double);
 
        double y = *((double *)(rawClassData + dataPos));
        dataPos += sizeof(double);
 
        plotDataValues.append(QPointF(x, y));
      }
 
      setData(new QwtPointSeriesData(plotDataValues));
      ASSERT(dataPos <= classData.size());
 
      return classData.right(classData.size() - dataPos);
    }
    else {
      IString msg = "The given byte array is not large enough to contain the "
          "required header";
      throw IException(IException::Programmer, msg, _FILEINFO_);
    }
  }
 
 
  QByteArray PlotCurve::toByteArray() const {
    QByteArray classData;
 
    QString header("PLOT_CURVE_V1");
    classData.append(header.toUtf8());
 
    QByteArray titleArray = title().text().toUtf8();
    int size = titleArray.size();
    classData.append((char *)&size, sizeof(int));
    classData.append(titleArray);
 
    int xUnitsInt = (int)m_xUnits;
    int yUnitsInt = (int)m_yUnits;
    classData.append((char *)&xUnitsInt, sizeof(int));
    classData.append((char *)&yUnitsInt, sizeof(int));
 
    // Store the pen... to do this we need to serialize using QPen's operators
    QBuffer penDataBuffer;
    penDataBuffer.open(QIODevice::ReadWrite);
 
    QDataStream penDataStream(&penDataBuffer);
    penDataStream << pen();
    penDataBuffer.seek(0);
 
    size = penDataBuffer.buffer().size();
    classData.append((char *)&size, sizeof(int));
    classData.append(penDataBuffer.buffer());
 
    // Store the color...
    QBuffer colorDataBuffer;
    colorDataBuffer.open(QIODevice::ReadWrite);
 
    QDataStream colorDataStream(&colorDataBuffer);
    colorDataStream << m_color;
    colorDataBuffer.seek(0);
 
    size = colorDataBuffer.buffer().size();
    classData.append((char *)&size, sizeof(int));
    classData.append(colorDataBuffer.buffer());
 
    // Store the marker symbol...
    QBuffer markerSymbolDataBuffer;
    markerSymbolDataBuffer.open(QIODevice::ReadWrite);
 
    QDataStream markerSymbolDataStream(&markerSymbolDataBuffer);
    markerSymbolDataStream << m_markerSymbol->brush();
    markerSymbolDataStream << m_markerSymbol->pen();
    markerSymbolDataStream << m_markerSymbol->size();
    markerSymbolDataStream << (int)m_markerSymbol->style();
    markerSymbolDataBuffer.seek(0);
 
    size = markerSymbolDataBuffer.buffer().size();
    classData.append((char *)&size, sizeof(int));
    classData.append(markerSymbolDataBuffer.buffer());
 
    // Store the X/Y plot values
    const QwtSeriesData<QPointF> &plotData = *data();
    size = plotData.size();
    classData.append((char *)&size, sizeof(int));
 
    for (int i = 0; i < size; i ++) {
      double x = plotData.sample(i).x();
      double y = plotData.sample(i).y();
 
      classData.append((char *)&x, sizeof(double));
      classData.append((char *)&y, sizeof(double));
    }
 
    return classData;
  }
 
 
  void PlotCurve::setPen(const QPen &pen) {
    QPen newPen(pen);
    newPen.setColor(m_color);
 
    QwtPlotCurve::setPen(newPen);
 
    recreateMarkers();
  }
 
 
  void PlotCurve::clearMarkers() {
    foreach (QwtPlotMarker *marker, m_valuePointMarkers) {
      marker->detach();
      //delete marker;
    }
 
    m_valuePointMarkers.clear();
  }
 
 
  void PlotCurve::recreateMarkers() {
    bool markersVisible = true;
    if (m_valuePointMarkers.size()) {
      markersVisible = m_valuePointMarkers.first()->isVisible();
    }
    clearMarkers();
 
    QPen markerPen = m_markerSymbol->pen();
    markerPen.setColor(m_color);
    m_markerSymbol->setPen(markerPen);
 
    const QwtSeriesData<QPointF> &plotData = *data();
    for(unsigned int i = 0; i < plotData.size(); i++) {
      QwtPlotMarker *newMarker = new QwtPlotMarker();
      newMarker->setValue(plotData.sample(i).x(), plotData.sample(i).y());
      newMarker->setAxes(xAxis(), yAxis());
      newMarker->setSymbol(m_markerSymbol);
      newMarker->setVisible(markersVisible);
      newMarker->attach(plot());
      m_valuePointMarkers.append(newMarker);
    }
  }
}