PacWaveformBase.h

Go to the documentation of this file.

/***************************************************************************
 *   Copyright (C) 2008 by Matthias Nagl   *
 *   mnagl@uni-goettingen.de   *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/
#ifndef PACWAVEFORMPLUGINBASE_H
#define PACWAVEFORMPLUGINBASE_H

#include <QObject>
#include <QDataStream>
#include <QByteArray>
#include <QVector>
#include <QGroupBox>
#include <QVBoxLayout>
#include <WaveformInterface.h>
#include <TransmittableProperty.h>
#include <PropertyBranch.h>
#include <limits>

class PacWaveformDataBase;
class QwtPlotCurve;
class QwtPlot;
class QwtPlotGrid;
class QwtPlotZoomer;
class QwtPlotMarker;
class QToolButton;

class PacWaveformBase
    : public QObject,
      public WaveformProcessingInterface,
      public PropertyBranch,
      public WaveformPresentationInterface
{
    Q_OBJECT
    Q_INTERFACES(WaveformProcessingInterface)
    Q_INTERFACES(WaveformPresentationInterface)

  public:
    PacWaveformBase(QObject *parent = 0, const QString &pluginname = "", const QString &pluginversion = "");
    virtual ~PacWaveformBase();

    virtual void setParentBranch(PropertyBranchInterface *p = 0);
    virtual QString name() const { return pluginname; }
    virtual QString version() const { return pluginversion; }
    //virtual void attachToPlot(QwtPlot *plot);
    virtual void setWaveformData(WaveformDataInterface *data);
    virtual WaveformDataInterface * tryDeserialization(const QByteArray &serialized) const;
    virtual void readUpdatedParameters();
    virtual QWidget * getWidget();
    virtual void setTitleString(const QString &);
    //virtual void deleteControlWidget();

  protected slots:
    void exportWaveform();

  protected:
    QWidget * createExportButton();
    const QString pluginname;
    const QString pluginversion;
    QString titlestring;
    virtual bool canDeserialize(const QByteArray &serialized) const;
    TransmittableProperty p_overflowlimit;
    qint32 overflowlimit;
    QVector<qreal> xvector, voltvector;
    QwtPlotCurve *waveform;
    QwtPlotMarker *waveformtrigger;
    QwtPlotGrid *waveformgrid;
    QPointer<QwtPlot> myplot;
    QPointer<QGroupBox> widget;
    QPointer<QWidget> controlwidget;
    QVBoxLayout *layout;
    QPointer<QwtPlotZoomer> wfzoomer;
    qreal xmin, xmax, ymin, ymax; 
    QPointer<QToolButton> exportbutton;
    const PacWaveformDataBase *currentwf;
    bool noupdates;
};

class PacWaveformDataBase
    : public WaveformDataInterface
{
  public:
    PacWaveformDataBase(const PacWaveformBase *creator = 0);
    PacWaveformDataBase(const PacWaveformBase *creator, const QByteArray &serialized);
    PacWaveformDataBase(const PacWaveformDataBase &original);
    virtual void clone(const WaveformDataInterface *original);
    virtual ~PacWaveformDataBase();

    virtual void setData(
      quint32 numsamples,
      const qint8 * dataArray,
      qulonglong triggertimestamp,
      qreal hpos,
      qint32 samplesbeforetrigger,
      qreal sampleinterval,
      qreal vgain,
      qreal voffset,
      qint8 polarity,
      qreal triggerlevel
    );

    qint32 overflowSamples() const;

    virtual QByteArray serialize(const QByteArray &childrensdata = QByteArray()) const;
    virtual QByteArray deserialize(const QByteArray &serialized);
    virtual qreal getCoulomb() const { analyze(); return coulomb; }
    virtual qulonglong getSignalOnset() const { analyze(); return onsettime; }
    virtual bool badWaveform() const { analyze(); return badwaveform; }
    virtual void setNodeId(quint16 nodeid) { nid = nodeid; }
    virtual quint16 nodeId() const { return nid; }
    virtual QString toCSV() const;
    friend void PacWaveformBase::setWaveformData(WaveformDataInterface *data);

  protected:
    virtual void analyze() const = 0;
    inline qreal sampleInVolts(quint32 i) const { return qreal(dataArray[i])*vgain-voffset-autooffset; }
    inline qreal sampleTime(qint32 i) const { return qreal(i-(samplesbeforetrigger+1))*sampleinterval+hpos; }
    inline qreal digitizersUpperLimitInVolts() const { return qreal(std::numeric_limits<qint8>::max())*vgain-voffset; }
    inline qreal digitizersLowerLimitInVolts() const { return qreal(std::numeric_limits<qint8>::min())*vgain-voffset; }
    inline qreal timescaleLowerLimit() const { return -qreal(samplesbeforetrigger+1+1)*sampleinterval; }
    inline qreal timescaleUpperLimit() const { return qreal(numsamples-(samplesbeforetrigger+1))*sampleinterval; }

    quint32 numsamples;
    qint8 *dataArray;
    qulonglong triggertimestamp;
    mutable qreal autooffset;
    mutable qint32 numoverflowsamples;
    mutable qreal coulomb;        
    mutable qulonglong onsettime; 
    mutable bool badwaveform;     
    qint32 samplesbeforetrigger;
    qreal hpos, sampleinterval, vgain, voffset;
    qint8 polarity;         
    qreal triggerlevel;     
    quint16 nid;
    const PacWaveformBase *creator;
};

#endif