QwtSyntheticPointData - Synthetic point data.

       Generated automatically by Doxygen for Qwt User's Guide from the source code.

Version 6.1.4                                    Wed Jan 2 2019                         QwtSyntheticPointData(3)

QwtSyntheticPointData::QwtSyntheticPointData(size_tsize,constQwtInterval&interval=QwtInterval())
       Constructor

       Parameters:size Number of points
           interval Bounding interval for the points

       Seealso:setInterval(), setSize()

       Synthetic point data.

       QwtSyntheticPointData provides a fixed number of points for an interval. The points are calculated in
       equidistant steps in x-direction.

       If the interval is invalid, the points are calculated for the 'rectangle of interest', what normally is
       the displayed area on the plot canvas. In this mode you get different levels of detail, when zooming
       in/out.

       Example

       The following example shows how to implement a sinus curve.

       #include <cmath>
       #include <qwt_series_data.h>
       #include <qwt_plot_curve.h>
       #include <qwt_plot.h>
       #include <qapplication.h>

       class SinusData: public QwtSyntheticPointData
       {
       public:
           SinusData():
               QwtSyntheticPointData( 100 )
           {
           }

           virtual double y( double x ) const
           {
               return qSin( x );
           }
       };

       int main(int argc, char **argv)
       {
           QApplication a( argc, argv );

           QwtPlot plot;
           plot.setAxisScale( QwtPlot::xBottom, 0.0, 10.0 );
           plot.setAxisScale( QwtPlot::yLeft, -1.0, 1.0 );

           QwtPlotCurve *curve = new QwtPlotCurve( "y = sin(x)" );
           curve->setData( new SinusData() );
           curve->attach( &plot );

           plot.show();
           return a.exec();
       }

QRectFQwtSyntheticPointData::boundingRect()const[virtual]
       Calculate the bounding rectangle. This implementation iterates over all points, what could often be
       implemented much faster using the characteristics of the series. When there are many points it is
       recommended to overload and reimplement this method using the characteristics of the series ( if possible
       ).

       Returns:
           Bounding rectangle

       Implements QwtSeriesData<QPointF>.

   QwtIntervalQwtSyntheticPointData::interval()constReturns:
           Bounding interval

       Seealso:setInterval(), size()QRectFQwtSyntheticPointData::rectOfInterest()constReturns:Seealso:setRectOfInterest()QPointFQwtSyntheticPointData::sample(size_tindex)const[virtual]
       Calculate the point from an index

       Parameters:index Index

       Returns:
           QPointF(x(index), y(x(index)));

       Warning:
           For invalid indices ( index < 0 || index >= size() ) (0, 0) is returned.

       Implements QwtSeriesData<QPointF>.

   voidQwtSyntheticPointData::setInterval(constQwtInterval&interval)
       Set the bounding interval

       Parameters:interval Interval

       Seealso:interval(), setSize()voidQwtSyntheticPointData::setRectOfInterest(constQRectF&rect)[virtual]
       Set a the 'rectangle of interest'

       QwtPlotSeriesItem defines the current area of the plot canvas as 'rect of interest' (
       QwtPlotSeriesItem::updateScaleDiv() ).

       If interval().isValid() == false the x values are calculated in the interval rect.left() -> rect.right().

       Seealso:rectOfInterest()

       Reimplemented from QwtSeriesData<QPointF>.

   voidQwtSyntheticPointData::setSize(size_tsize)
       Change the number of points

       Parameters:size Number of points

       Seealso:size(), setInterval()size_tQwtSyntheticPointData::size()const[virtual]Returns:
           Number of points

       Seealso:setSize(), interval()

       Implements QwtSeriesData<QPointF>.

   doubleQwtSyntheticPointData::x(uintindex)const[virtual]
       Calculate a x-value from an index

       x values are calculated by dividing an interval into equidistant steps. If !interval().isValid() the
       interval is calculated from the 'rectangle of interest'.

       Parameters:index Index of the requested point

       Returns:
           Calculated x coordinate

       Seealso:interval(), rectOfInterest(), y()virtualdoubleQwtSyntheticPointData::y(doublex)const[purevirtual]
       Calculate a y value for a x value

       Parameters:x x value

       Returns:
           Corresponding y value

       QwtSyntheticPointData - Synthetic point data.

       #include <qwt_point_data.h>

       Inherits QwtSeriesData<QPointF>.

   PublicMemberFunctionsQwtSyntheticPointData (size_t size, const QwtInterval &=QwtInterval())
       void setSize (size_t size)
       virtual size_t size () const
       void setInterval (const QwtInterval &)
       QwtIntervalinterval () const
       virtual QRectF boundingRect () const
           Calculate the bounding rectangle.
       virtual QPointF sample (size_t index) const
       virtual double y (double x) const =0
       virtual double x (uint index) const
       virtual void setRectOfInterest (const QRectF &)
       QRectF rectOfInterest () const

   AdditionalInheritedMembers