qwt_point_data.h

Go to the documentation of this file.

/* -*- mode: C++ ; c-file-style: "stroustrup" -*- *****************************
 * 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
 *****************************************************************************/

#ifndef QWT_POINT_DATA_H
#define QWT_POINT_DATA_H

#include "qwt_global.h"
#include "qwt_series_data.h"

#include <cstring>

template <typename T>
class QwtPointArrayData: public QwtPointSeriesData
{
public:
    QwtPointArrayData( const QVector<T> &x, const QVector<T> &y );
    QwtPointArrayData( const T *x, const T *y, size_t size );

    virtual size_t size() const QWT_OVERRIDE;
    virtual QPointF sample( size_t index ) const QWT_OVERRIDE;

    const QVector<T> &xData() const;
    const QVector<T> &yData() const;

private:
    QVector<T> d_x;
    QVector<T> d_y;
};

template <typename T>
class QwtCPointerData: public QwtPointSeriesData
{
public:
    QwtCPointerData( const T *x, const T *y, size_t size );

    virtual size_t size() const QWT_OVERRIDE;
    virtual QPointF sample( size_t index ) const QWT_OVERRIDE;

    const T *xData() const;
    const T *yData() const;

private:
    const T *d_x;
    const T *d_y;
    size_t d_size;
};

template <typename T>
class QwtValuePointData: public QwtPointSeriesData
{
public:
    QwtValuePointData( const QVector<T> &y );
    QwtValuePointData( const T *y, size_t size );

    virtual size_t size() const QWT_OVERRIDE;
    virtual QPointF sample( size_t index ) const QWT_OVERRIDE;

    const QVector<T> &yData() const;

private:
    QVector<T> d_y;
};

template <typename T>
class QwtCPointerValueData: public QwtPointSeriesData
{
public:
    QwtCPointerValueData( const T *y, size_t size );

    virtual size_t size() const QWT_OVERRIDE;
    virtual QPointF sample( size_t index ) const QWT_OVERRIDE;

    const T *yData() const;

private:
    const T *d_y;
    size_t d_size;
};

class QWT_EXPORT QwtSyntheticPointData: public QwtPointSeriesData
{
public:
    QwtSyntheticPointData( size_t size,
        const QwtInterval & = QwtInterval() );

    void setSize( size_t size );
    virtual size_t size() const QWT_OVERRIDE;

    void setInterval( const QwtInterval& );
    QwtInterval interval() const;

    virtual QRectF boundingRect() const QWT_OVERRIDE;
    virtual QPointF sample( size_t index ) const QWT_OVERRIDE;

    virtual double y( double x ) const = 0;
    virtual double x( uint index ) const;

    virtual void setRectOfInterest( const QRectF & ) QWT_OVERRIDE;
    QRectF rectOfInterest() const;

private:
    size_t d_size;
    QwtInterval d_interval;
    QRectF d_rectOfInterest;
    QwtInterval d_intervalOfInterest;
};

template <typename T>
QwtPointArrayData<T>::QwtPointArrayData(
        const QVector<T> &x, const QVector<T> &y ):
    d_x( x ),
    d_y( y )
{
}

template <typename T>
QwtPointArrayData<T>::QwtPointArrayData(
    const T *x, const T *y, size_t size )
{
    d_x.resize( size );
    std::memcpy( d_x.data(), x, size * sizeof( T ) );

    d_y.resize( size );
    std::memcpy( d_y.data(), y, size * sizeof( T ) );
}

template <typename T>
size_t QwtPointArrayData<T>::size() const
{
    return qMin( d_x.size(), d_y.size() );
}

template <typename T>
QPointF QwtPointArrayData<T>::sample( size_t index ) const
{
    return QPointF( d_x[int( index )], d_y[int( index )] );
}

template <typename T>
const QVector<T> &QwtPointArrayData<T>::xData() const
{
    return d_x;
}

template <typename T>
const QVector<T> &QwtPointArrayData<T>::yData() const
{
    return d_y;
}

template <typename T>
QwtValuePointData<T>::QwtValuePointData( const QVector<T> &y ):
    d_y( y )
{
}

template <typename T>
QwtValuePointData<T>::QwtValuePointData( const T *y, size_t size )
{
    d_y.resize( size );
    std::memcpy( d_y.data(), y, size * sizeof( T ) );
}

template <typename T>
size_t QwtValuePointData<T>::size() const
{
    return d_y.size();
}

template <typename T>
QPointF QwtValuePointData<T>::sample( size_t index ) const
{
    return QPointF( index, d_y[int( index )] );
}

template <typename T>
const QVector<T> &QwtValuePointData<T>::yData() const
{
    return d_y;
}

template <typename T>
QwtCPointerData<T>::QwtCPointerData( const T *x, const T *y, size_t size ):
    d_x( x ),
    d_y( y ),
    d_size( size )
{
}

template <typename T>
size_t QwtCPointerData<T>::size() const
{
    return d_size;
}

template <typename T>
QPointF QwtCPointerData<T>::sample( size_t index ) const
{
    return QPointF( d_x[int( index )], d_y[int( index )] );
}

template <typename T>
const T *QwtCPointerData<T>::xData() const
{
    return d_x;
}

template <typename T>
const T *QwtCPointerData<T>::yData() const
{
    return d_y;
}

template <typename T>
QwtCPointerValueData<T>::QwtCPointerValueData( const T *y, size_t size ):
    d_y( y ),
    d_size( size )
{
}

template <typename T>
size_t QwtCPointerValueData<T>::size() const
{
    return d_size;
}

template <typename T>
QPointF QwtCPointerValueData<T>::sample( size_t index ) const
{
    return QPointF( index, d_y[ int( index ) ] );
}

template <typename T>
const T *QwtCPointerValueData<T>::yData() const
{
    return d_y;
}

#endif