Released version 6.1.3

examples/animation/animation.pro

@@ -0,0 +1,19 @@
+################################################################
+# Qwt Widget Library
+# Copyright (C) 1997   Josef Wilgen
+# Copyright (C) 2002   Uwe Rathmann
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the Qwt License, Version 1.0
+################################################################
+
+include( $${PWD}/../examples.pri )
+
+TARGET  = animation
+
+HEADERS = \
+    plot.h
+
+SOURCES = \
+    plot.cpp \
+    main.cpp

examples/animation/main.cpp

@@ -0,0 +1,46 @@
+#include <qapplication.h>
+#include "plot.h"
+
+#ifndef QWT_NO_OPENGL
+#define USE_OPENGL 1
+#endif
+
+#if USE_OPENGL
+#include <qgl.h>
+#include <qwt_plot_glcanvas.h>
+#else
+#include <qwt_plot_canvas.h>
+#endif
+
+int main ( int argc, char **argv )
+{
+#if USE_OPENGL
+#if QT_VERSION >= 0x040600 && QT_VERSION < 0x050000
+    // on my box QPaintEngine::OpenGL2 has serious problems, f.e:
+    // the lines of a simple drawRect are wrong.
+
+    QGL::setPreferredPaintEngine( QPaintEngine::OpenGL );
+#endif
+#endif
+
+    QApplication a( argc, argv );
+
+    Plot plot;
+
+#if USE_OPENGL
+    QwtPlotGLCanvas *canvas = new QwtPlotGLCanvas();
+    canvas->setFrameStyle( QwtPlotGLCanvas::NoFrame );
+#else
+    QwtPlotCanvas *canvas = new QwtPlotCanvas();
+    canvas->setFrameStyle( QFrame::NoFrame );
+    canvas->setPaintAttribute( QwtPlotCanvas::BackingStore, false );
+#endif
+
+    plot.setCanvas( canvas );
+    plot.setCanvasBackground( QColor( 30, 30, 50 ) );
+
+    plot.resize( 400, 400 );
+    plot.show();
+
+    return a.exec();
+}

examples/animation/plot.cpp

@@ -0,0 +1,241 @@
+#include <qapplication.h>
+#include <qwt_math.h>
+#include <qwt_symbol.h>
+#include <qwt_curve_fitter.h>
+#include <qwt_plot_curve.h>
+#include <qwt_plot_canvas.h>
+#include <qwt_plot_layout.h>
+#include <qevent.h>
+#include "plot.h"
+
+class Curve: public QwtPlotCurve
+{
+public:
+    void setTransformation( const QTransform &transform )
+    {
+        d_transform = transform;
+    }
+
+    virtual void updateSamples( double phase )
+    {
+        setSamples( d_transform.map( points( phase ) ) );
+    }
+
+private:
+    virtual QPolygonF points( double phase ) const = 0;
+
+private:
+    QTransform d_transform;
+};
+
+class Curve1: public Curve
+{
+public:
+    Curve1()
+    {
+        setPen( QColor( 150, 150, 200 ), 2 );
+        setStyle( QwtPlotCurve::Lines );
+
+        QwtSplineCurveFitter *curveFitter = new QwtSplineCurveFitter();
+        curveFitter->setSplineSize( 150 );
+        setCurveFitter( curveFitter );
+
+        setCurveAttribute( QwtPlotCurve::Fitted, true );
+
+        QwtSymbol *symbol = new QwtSymbol( QwtSymbol::XCross );
+        symbol->setPen( Qt::yellow );
+        symbol->setSize( 7 );
+
+        setSymbol( symbol );
+
+        // somewhere to the left
+        QTransform transform;
+        transform.scale( 1.5, 1.0 );
+        transform.translate( 1.5, 3.0 );
+
+        setTransformation( transform );
+    }
+
+    virtual QPolygonF points( double phase ) const
+    {
+        QPolygonF points;
+
+        const int numSamples = 15;
+        for ( int i = 0; i < numSamples; i++ )
+        {
+            const double v = 6.28 * double( i ) / double( numSamples - 1 );
+            points += QPointF( qSin( v - phase ), v );
+        }
+
+        return points;
+    }
+};
+
+class Curve2: public Curve
+{
+public:
+    Curve2()
+    {
+        setStyle( QwtPlotCurve::Sticks );
+        setPen( QColor( 200, 150, 50 ) );
+
+        setSymbol( new QwtSymbol( QwtSymbol::Ellipse,
+            QColor( Qt::gray ), QColor( Qt::yellow ), QSize( 5, 5 ) ) );
+    }
+
+private:
+    virtual QPolygonF points( double phase ) const
+    {
+        QPolygonF points;
+
+        const int numSamples = 50;
+        for ( int i = 0; i < numSamples; i++ )
+        {
+            const double v = 10.0 * i / double( numSamples - 1 );
+            points += QPointF( v, qCos( 3.0 * ( v + phase ) ) );
+        }
+
+        return points;
+    }
+};
+
+class Curve3: public Curve
+{       
+public: 
+    Curve3()
+    {
+        setStyle( QwtPlotCurve::Lines );
+        setPen( QColor( 100, 200, 150 ), 2 );
+
+        QwtSplineCurveFitter* curveFitter = new QwtSplineCurveFitter();
+        curveFitter->setFitMode( QwtSplineCurveFitter::ParametricSpline );
+        curveFitter->setSplineSize( 200 );
+        setCurveFitter( curveFitter );
+
+        setCurveAttribute( QwtPlotCurve::Fitted, true );
+
+        // somewhere in the top right corner
+        QTransform transform;
+        transform.translate( 7.0, 7.5 );
+        transform.scale( 2.0, 2.0 );
+
+        setTransformation( transform );
+    }   
+
+private:
+    virtual QPolygonF points( double phase ) const
+    {
+        QPolygonF points;
+
+        const int numSamples = 9;
+        for ( int i = 0; i < numSamples; i++ )
+        {
+            const double v = i * 2.0 * M_PI / ( numSamples - 1 );
+            points += QPointF( qSin( v - phase ), qCos( 3.0 * ( v + phase ) ) );
+        }
+
+        return points;
+    }
+};  
+
+class Curve4: public Curve
+{       
+public: 
+    Curve4()
+    {
+        setStyle( QwtPlotCurve::Lines );
+        setPen( Qt::red, 2 );
+
+        initSamples();
+
+        // somewhere in the center
+        QTransform transform;
+        transform.translate( 7.0, 3.0 );
+        transform.scale( 1.5, 1.5 );
+
+        setTransformation( transform );
+    }   
+
+private:
+    virtual QPolygonF points( double phase ) const
+    {
+        const double speed = 0.05;
+
+        const double s = speed * qSin( phase );
+        const double c = qSqrt( 1.0 - s * s );
+
+        for ( int i = 0; i < d_points.size(); i++ )
+        {
+            const QPointF p = d_points[i];
+
+            const double u = p.x();
+            const double v = p.y();
+
+            d_points[i].setX( u * c - v * s );
+            d_points[i].setY( v * c + u * s );
+        }
+
+        return d_points;
+    }
+
+    void initSamples()
+    {
+        const int numSamples = 15;
+
+        for ( int i = 0; i < numSamples; i++ )
+        {
+            const double angle = i * ( 2.0 * M_PI / ( numSamples - 1 ) );
+
+            QPointF p( qCos( angle ), qSin( angle ) );
+            if ( i % 2 )
+                p *= 0.4;
+            
+            d_points += p;
+        }
+    }
+
+private:
+    mutable QPolygonF d_points;
+};  
+
+Plot::Plot( QWidget *parent ):
+    QwtPlot( parent)
+{
+    setAutoReplot( false );
+
+    setTitle( "Animated Curves" );
+
+    // hide all axes
+    for ( int axis = 0; axis < QwtPlot::axisCnt; axis++ )
+        enableAxis( axis, false );
+
+    plotLayout()->setCanvasMargin( 10 );
+
+    d_curves[0] = new Curve1();
+    d_curves[1] = new Curve2();
+    d_curves[2] = new Curve3();
+    d_curves[3] = new Curve4();
+
+    updateCurves();
+
+    for ( int i = 0; i < CurveCount; i++ )
+        d_curves[i]->attach( this );
+
+    d_time.start();
+    ( void )startTimer( 40 );
+}
+
+void Plot::timerEvent( QTimerEvent * )
+{
+    updateCurves();
+    replot();
+}
+
+void Plot::updateCurves()
+{
+    const double speed = 2 * M_PI / 25000.0; // a cycle every 25 seconds
+
+    const double phase = d_time.elapsed() * speed;
+    for ( int i = 0; i < CurveCount; i++ )
+        d_curves[i]->updateSamples( phase );
+}

examples/animation/plot.h

@@ -0,0 +1,21 @@
+#include <qwt_plot.h>
+#include <qdatetime.h>
+
+class Curve;
+
+class Plot: public QwtPlot
+{
+public:
+    Plot( QWidget * = NULL);
+
+protected:
+    virtual void timerEvent( QTimerEvent * );
+
+private:
+    void updateCurves();
+
+    enum { CurveCount = 4 };
+    Curve *d_curves[CurveCount];
+
+    QTime d_time;
+};