qwt_point_data.h

/******************************************************************************
 * 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
 *
 * Modified by ChenZongYan in 2024 <czy.t@163.com>
 *   Summary of major modifications (see ChangeLog.md for full history):
 *   1. CMake build system & C++11 throughout.
 *   2. Core panner/ zoomer refactored:
 *        - QwtPanner → QwtCachePanner (pixmap-cache version)
 *        - New real-time QwtPlotPanner derived from QwtPicker.
 *   3. Zoomer supports multi-axis.
 *   4. Parasite-plot framework:
 *        - QwtFigure, QwtPlotParasiteLayout, QwtPlotTransparentCanvas,
 *        - QwtPlotScaleEventDispatcher, built-in pan/zoom on axis.
 *   5. New picker: QwtPlotSeriesDataPicker (works with date axis).
 *   6. Raster & color-map extensions:
 *        - QwtGridRasterData (2-D table + interpolation)
 *        - QwtLinearColorMap::stopColors(), stopPos() API rename.
 *   7. Bar-chart: expose pen/brush control.
 *   8. Amalgamated build: single QwtPlot.h / QwtPlot.cpp pair in src-amalgamate.
 *****************************************************************************/
 
#ifndef QWT_POINT_DATA_H
#define QWT_POINT_DATA_H
 
#include "qwtcore_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(QVector< T >&& x, QVector< T >&& y);
    QwtPointArrayData(const T* x, const T* y, size_t size);
 
    virtual size_t size() const override;
    virtual QPointF sample(size_t index) const override;
 
    const QVector< T >& xData() const;
    const QVector< T >& yData() const;
 
private:
    QVector< T > m_x;
    QVector< T > m_y;
};
 
template< typename T >
class QwtCPointerData : public QwtPointSeriesData
{
public:
    QwtCPointerData(const T* x, const T* y, size_t size);
 
    virtual size_t size() const override;
    virtual QPointF sample(size_t index) const override;
 
    const T* xData() const;
    const T* yData() const;
 
private:
    const T* m_x;
    const T* m_y;
    size_t m_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 override;
    virtual QPointF sample(size_t index) const override;
 
    const QVector< T >& yData() const;
 
private:
    QVector< T > m_y;
};
 
template< typename T >
class QwtCPointerValueData : public QwtPointSeriesData
{
public:
    QwtCPointerValueData(const T* y, size_t size);
 
    virtual size_t size() const override;
    virtual QPointF sample(size_t index) const override;
 
    const T* yData() const;
 
private:
    const T* m_y;
    size_t m_size;
};
 
class QWTCORE_EXPORT QwtSyntheticPointData : public QwtPointSeriesData
{
public:
    // Constructor
    QwtSyntheticPointData(size_t size, const QwtInterval& = QwtInterval());
 
    // Set the number of points
    void setSize(size_t size);
    // Get the number of points
    virtual size_t size() const override;
 
    // Set the interval
    void setInterval(const QwtInterval&);
    // Get the interval
    QwtInterval interval() const;
 
    // Get the bounding rectangle
    virtual QRectF boundingRect() const override;
    // Get the sample at a specific index
    virtual QPointF sample(size_t index) const override;
 
    // Calculate a y value for a x value
    virtual double y(double x) const = 0;
    // Calculate the x value for a given index
    virtual double x(size_t index) const;
 
    // Set the rectangle of interest
    virtual void setRectOfInterest(const QRectF&) override;
    // Get the rectangle of interest
    QRectF rectOfInterest() const;
 
private:
    size_t m_size;
    QwtInterval m_interval;
    QRectF m_rectOfInterest;
    QwtInterval m_intervalOfInterest;
};
 
template< typename T >
QwtPointArrayData< T >::QwtPointArrayData(const QVector< T >& x, const QVector< T >& y) : m_x(x), m_y(y)
{
}
 
template< typename T >
QwtPointArrayData< T >::QwtPointArrayData(QVector< T >&& x, QVector< T >&& y)
{
    m_x = std::move(x);
    m_y = std::move(y);
}
 
template< typename T >
QwtPointArrayData< T >::QwtPointArrayData(const T* x, const T* y, size_t size)
{
    m_x.resize(size);
    std::memcpy(m_x.data(), x, size * sizeof(T));
 
    m_y.resize(size);
    std::memcpy(m_y.data(), y, size * sizeof(T));
}
 
template< typename T >
size_t QwtPointArrayData< T >::size() const
{
    return qMin(m_x.size(), m_y.size());
}
 
template< typename T >
QPointF QwtPointArrayData< T >::sample(size_t index) const
{
    return QPointF(m_x[ int(index) ], m_y[ int(index) ]);
}
 
template< typename T >
const QVector< T >& QwtPointArrayData< T >::xData() const
{
    return m_x;
}
 
template< typename T >
const QVector< T >& QwtPointArrayData< T >::yData() const
{
    return m_y;
}
 
template< typename T >
QwtValuePointData< T >::QwtValuePointData(const QVector< T >& y) : m_y(y)
{
}
 
template< typename T >
QwtValuePointData< T >::QwtValuePointData(const T* y, size_t size)
{
    m_y.resize(size);
    std::memcpy(m_y.data(), y, size * sizeof(T));
}
 
template< typename T >
size_t QwtValuePointData< T >::size() const
{
    return m_y.size();
}
 
template< typename T >
QPointF QwtValuePointData< T >::sample(size_t index) const
{
    return QPointF(index, m_y[ int(index) ]);
}
 
template< typename T >
const QVector< T >& QwtValuePointData< T >::yData() const
{
    return m_y;
}
 
template< typename T >
QwtCPointerData< T >::QwtCPointerData(const T* x, const T* y, size_t size) : m_x(x), m_y(y), m_size(size)
{
}
 
template< typename T >
size_t QwtCPointerData< T >::size() const
{
    return m_size;
}
 
template< typename T >
QPointF QwtCPointerData< T >::sample(size_t index) const
{
    return QPointF(m_x[ int(index) ], m_y[ int(index) ]);
}
 
template< typename T >
const T* QwtCPointerData< T >::xData() const
{
    return m_x;
}
 
template< typename T >
const T* QwtCPointerData< T >::yData() const
{
    return m_y;
}
 
template< typename T >
QwtCPointerValueData< T >::QwtCPointerValueData(const T* y, size_t size) : m_y(y), m_size(size)
{
}
 
template< typename T >
size_t QwtCPointerValueData< T >::size() const
{
    return m_size;
}
 
template< typename T >
QPointF QwtCPointerValueData< T >::sample(size_t index) const
{
    return QPointF(index, m_y[ int(index) ]);
}
 
template< typename T >
const T* QwtCPointerValueData< T >::yData() const
{
    return m_y;
}
 
#endif