datastreamplot.cpp

/********************************************************************************
 *  FARSA DataStreamPlot UI                                                     *
 *  Copyright (C) 2012-2013                                                     *
 *  Gianluca Massera <emmegian@yahoo.it>                                        *
 *                                                                              *
 *  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., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA  *
 ********************************************************************************/

#include "datastreamplot.h"
#include "qwt/qwt_plot_grid.h"
#include "qwt/qwt_plot_layout.h"
#include "qwt/qwt_plot_canvas.h"
#include "qwt/qwt_plot_curve.h"
#include "qwt/qwt_symbol.h"
#include "qwt/qwt_plot_directpainter.h"
#include "qwt/qwt_painter.h"
#include "qwt/qwt_legend.h"
#include "qwt/qwt_legend_label.h"
#include <QPaintEngine>

namespace farsa {

class DataStream: public QwtArraySeriesData<QPointF> {
public:
    DataStream() : QwtArraySeriesData<QPointF>() { };
    // return the bouding rect of the data
    virtual QRectF boundingRect() const {
        if ( d_boundingRect.width() < 0.0 ) {
            d_boundingRect = qwtBoundingRect( *this );
        }
        return d_boundingRect;
    }
    virtual QPointF sample(size_t i) const {
        QPointF f = QwtArraySeriesData<QPointF>::sample(i);
        return f;
    }
    // append a new point to the data stream
    inline void append( const QPointF &point ) {
        d_samples += point;
    }
    // remove all points from the data stream
    void clear() {
        d_samples.clear();
        d_samples.squeeze();
        // it invalidate the bounding rect
        d_boundingRect = QRectF( 0.0, 0.0, -1.0, -1.0 );
    }
};

DataStreamPlot::DataStreamPlot( QWidget* parent ) :
    QwtPlot( parent ),
    streams(),
    directPainter(new QwtPlotDirectPainter( this )) {

    setFrameStyle( QFrame::NoFrame );
    setLineWidth( 0 );

    plotLayout()->setAlignCanvasToScales( true );

    QwtPlotGrid *grid = new QwtPlotGrid;
    grid->setMajorPen( Qt::gray, 0, Qt::DotLine );
    grid->attach( this );

    QwtLegend *legend = new QwtLegend;
    legend->setDefaultItemMode( QwtLegendData::Checkable );
    insertLegend( legend, QwtPlot::RightLegend );
    connect( legend, SIGNAL( checked( const QVariant &, bool, int ) ),
        SLOT( legendChecked( const QVariant &, bool ) ) );

    setCanvasBackground( Qt::lightGray );

    minY = 0;
    maxY = 1;
    maxX = 0;
    windowSize = 100;
    updatePlot();
    setAutoReplot( false );
}

DataStreamPlot::~DataStreamPlot() {
    foreach( QwtPlotCurve* curve, streams ) {
        delete curve;
    }
}

int DataStreamPlot::addDataStream( QString name ) {
    QwtPlotCurve* curve = new QwtPlotCurve( name );
    curve->setData( new DataStream() );
    curve->attach( this );
    curve->setYAxis( QwtPlot::yLeft );
    showCurve( curve, true );
    streams.append( curve );
    return streams.size()-1;
}

void DataStreamPlot::setDataStreamColor( int streamID, QColor color ) {
    color.setAlpha( 150 );
    streams[streamID]->setPen( color );
    streams[streamID]->setBrush( color );
}

void DataStreamPlot::appendData( int streamID, float value ) {
    DataStream* data = static_cast<DataStream*>( streams[streamID]->data() );
    QPointF point( data->size(), value );
    data->append( point );

    // plot the new point just added
    directPainter->drawSeries( streams[streamID], data->size()-1, data->size()-1 );
    maxX = qMax( maxX, (float)data->size() );
    if ( streams[streamID]->isVisible() ) {
        minY = qMin( minY, value );
        maxY = qMax( maxY, value );
    }
}

void DataStreamPlot::updatePlot() {
    setAxisScale( QwtPlot::yLeft, minY, maxY );
    float max = qMax( windowSize, maxX );
    float min = qMax( 0.0f, max-windowSize );
    setAxisScale( QwtPlot::xBottom, min, max );
    replot();
}

void DataStreamPlot::legendChecked( const QVariant &itemInfo, bool on ) {
    QwtPlotItem *plotItem = infoToItem( itemInfo );
    if ( plotItem ) {
        showCurve( plotItem, on );
        if ( !on ) {
            // when something will be hide, we reset the minY and maxY values
            minY = 0;
            maxY = 0;
        }
    }
}

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

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

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

    if ( legendWidgets.size() == 1 ) {
        QwtLegendLabel* legendLabel = qobject_cast<QwtLegendLabel*>( legendWidgets[0] );
        if ( legendLabel ) {
            legendLabel->setChecked( on );
        }
    }
    replot();
}

} // end namespace farsa