qwt_series_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_SERIES_DATA_H
#define QWT_SERIES_DATA_H
 
#include "qwtcore_global.h"
#include "qwt_samples.h"
#include "qwt_point_3d.h"
 
#include <qvector.h>
#include <qrect.h>
 
class QwtPointPolar;
 
QWTCORE_EXPORT bool isSampleNanOrInf(const QPointF& sample);
 
QWTCORE_EXPORT bool isSampleNanOrInf(const QwtPoint3D& sample);
 
QWTCORE_EXPORT bool isSampleNanOrInf(const QwtPointPolar& sample);
 
QWTCORE_EXPORT bool isSampleNanOrInf(const QwtSetSample& sample);
 
QWTCORE_EXPORT bool isSampleNanOrInf(const QwtIntervalSample& sample);
 
QWTCORE_EXPORT bool isSampleNanOrInf(const QwtOHLCSample& sample);
 
QWTCORE_EXPORT bool isSampleNanOrInf(const QwtVectorFieldSample& sample);
 
QWTCORE_EXPORT bool isSampleNanOrInf(const QwtBoxSample& sample);
 
QWTCORE_EXPORT bool isSampleNanOrInf(const QwtBoxOutlierSample& sample);
 
template< typename T >
class QwtSeriesData
{
public:
    QwtSeriesData();
 
    virtual ~QwtSeriesData();
 
#ifndef QWT_PYTHON_WRAPPER
 
    virtual size_t size() const = 0;
 
    virtual T sample(size_t i) const = 0;
 
    virtual QRectF boundingRect() const = 0;
 
#else
    // Needed for generating the python bindings, but not for using them !
    virtual size_t size() const
    {
        return 0;
    }
    virtual T sample(size_t i) const
    {
        return T();
    }
    virtual QRectF boundingRect() const
    {
        return cachedBoundingRect;
    }
#endif
 
    virtual void setRectOfInterest(const QRectF& rect);
 
protected:
    mutable QRectF cachedBoundingRect;
 
private:
    QwtSeriesData< T >& operator=(const QwtSeriesData< T >&);
};
 
template< typename T >
QwtSeriesData< T >::QwtSeriesData() : cachedBoundingRect(0.0, 0.0, -1.0, -1.0)
{
}
 
template< typename T >
QwtSeriesData< T >::~QwtSeriesData()
{
}
 
template< typename T >
void QwtSeriesData< T >::setRectOfInterest(const QRectF&)
{
}
 
template< typename T >
class QwtArraySeriesData : public QwtSeriesData< T >
{
public:
    QwtArraySeriesData();
 
    explicit QwtArraySeriesData(const QVector< T >& samples);
    explicit QwtArraySeriesData(QVector< T >&& samples);
 
    void setSamples(const QVector< T >& samples);
    void setSamples(QVector< T >&& samples);
 
    const QVector< T > samples() const;
 
    virtual size_t size() const override;
 
    virtual T sample(size_t index) const override;
 
protected:
    QVector< T > m_samples;
};
 
template< typename T >
QwtArraySeriesData< T >::QwtArraySeriesData()
{
}
 
template< typename T >
QwtArraySeriesData< T >::QwtArraySeriesData(const QVector< T >& samples) : m_samples(samples)
{
}
 
template< typename T >
QwtArraySeriesData< T >::QwtArraySeriesData(QVector< T >&& samples)
{
    m_samples = std::move(samples);
}
 
template< typename T >
void QwtArraySeriesData< T >::setSamples(const QVector< T >& samples)
{
    QwtSeriesData< T >::cachedBoundingRect = QRectF(0.0, 0.0, -1.0, -1.0);
    m_samples                              = samples;
}
 
template< typename T >
void QwtArraySeriesData< T >::setSamples(QVector< T >&& samples)
{
    QwtSeriesData< T >::cachedBoundingRect = QRectF(0.0, 0.0, -1.0, -1.0);
    m_samples                              = std::move(samples);
}
 
template< typename T >
const QVector< T > QwtArraySeriesData< T >::samples() const
{
    return m_samples;
}
 
template< typename T >
size_t QwtArraySeriesData< T >::size() const
{
    return m_samples.size();
}
 
template< typename T >
T QwtArraySeriesData< T >::sample(size_t i) const
{
    return m_samples[ static_cast< int >(i) ];
}
 
class QWTCORE_EXPORT QwtPointSeriesData : public QwtArraySeriesData< QPointF >
{
public:
    QwtPointSeriesData(const QVector< QPointF >& = QVector< QPointF >());
 
    virtual QRectF boundingRect() const override;
};
 
class QWTCORE_EXPORT QwtPoint3DSeriesData : public QwtArraySeriesData< QwtPoint3D >
{
public:
    QwtPoint3DSeriesData(const QVector< QwtPoint3D >& = QVector< QwtPoint3D >());
 
    virtual QRectF boundingRect() const override;
};
 
class QWTCORE_EXPORT QwtIntervalSeriesData : public QwtArraySeriesData< QwtIntervalSample >
{
public:
    QwtIntervalSeriesData(const QVector< QwtIntervalSample >& = QVector< QwtIntervalSample >());
 
    virtual QRectF boundingRect() const override;
};
 
class QWTCORE_EXPORT QwtSetSeriesData : public QwtArraySeriesData< QwtSetSample >
{
public:
    QwtSetSeriesData(const QVector< QwtSetSample >& = QVector< QwtSetSample >());
 
    virtual QRectF boundingRect() const override;
};
 
class QWTCORE_EXPORT QwtVectorFieldData : public QwtArraySeriesData< QwtVectorFieldSample >
{
public:
    QwtVectorFieldData(const QVector< QwtVectorFieldSample >& = QVector< QwtVectorFieldSample >());
 
    virtual QRectF boundingRect() const override;
};
 
class QWTCORE_EXPORT QwtTradingChartData : public QwtArraySeriesData< QwtOHLCSample >
{
public:
    QwtTradingChartData(const QVector< QwtOHLCSample >& = QVector< QwtOHLCSample >());
 
    virtual QRectF boundingRect() const override;
};
 
class QWTCORE_EXPORT QwtBoxChartData : public QwtArraySeriesData< QwtBoxSample >
{
public:
    QwtBoxChartData(const QVector< QwtBoxSample >& = QVector< QwtBoxSample >());
 
    virtual QRectF boundingRect() const override;
};
 
class QWTCORE_EXPORT QwtBoxOutlierChartData : public QwtArraySeriesData< QwtBoxOutlierSample >
{
public:
    QwtBoxOutlierChartData(const QVector< QwtBoxOutlierSample >& = QVector< QwtBoxOutlierSample >());
 
    virtual QRectF boundingRect() const override;
 
    int totalOutlierCount() const;
};
 
QWTCORE_EXPORT QRectF qwtBoundingRect(const QwtSeriesData< QPointF >&, size_t from = 0, size_t to = 0);
 
QWTCORE_EXPORT QRectF qwtBoundingRect(const QwtSeriesData< QwtPoint3D >&, size_t from = 0, size_t to = 0);
 
QWTCORE_EXPORT QRectF qwtBoundingRect(const QwtSeriesData< QwtPointPolar >&, size_t from = 0, size_t to = 0);
 
QWTCORE_EXPORT QRectF qwtBoundingRect(const QwtSeriesData< QwtIntervalSample >&, size_t from = 0, size_t to = 0);
 
QWTCORE_EXPORT QRectF qwtBoundingRect(const QwtSeriesData< QwtSetSample >&, size_t from = 0, size_t to = 0);
 
QWTCORE_EXPORT QRectF qwtBoundingRect(const QwtSeriesData< QwtOHLCSample >&, size_t from = 0, size_t to = 0);
 
QWTCORE_EXPORT QRectF qwtBoundingRect(const QwtSeriesData< QwtVectorFieldSample >&, size_t from = 0, size_t to = 0);
 
QWTCORE_EXPORT QRectF qwtBoundingRect(const QwtSeriesData< QwtBoxSample >&, size_t from = 0, size_t to = 0);
 
QWTCORE_EXPORT QRectF qwtBoundingRect(const QwtSeriesData< QwtBoxOutlierSample >&, size_t from = 0, size_t to = 0);
 
template< typename T, typename LessThan >
inline size_t qwtUpperSampleIndex(const QwtSeriesData< T >& series, double value, LessThan lessThan)
{
    const size_t count = series.size();
    if (count == 0) {
        return count;  // Return 0 as "not found" marker (valid indices start from 0, count is beyond valid range)
    }
 
    const size_t indexMax = count - 1;
 
    // If value is greater than or equal to the last element, no element is greater than value, return count
    if (!lessThan(value, series.sample(indexMax))) {
        return count;
    }
 
    size_t indexMin = 0;
    size_t n        = indexMax;  // n represents the current search interval size
 
    while (n > 0) {
        const size_t half     = n >> 1;
        const size_t indexMid = indexMin + half;
 
        if (lessThan(value, series.sample(indexMid))) {
            // Target is in the left interval [indexMin, indexMid]
            n = half;
        } else {
            // Target is in the right interval [indexMid + 1, indexMin + n - 1]
            indexMin = indexMid + 1;
            n -= half + 1;
        }
    }
 
    return indexMin;
}
 
#endif