qwt_samples.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_SAMPLES_H
#define QWT_SAMPLES_H
 
#include "qwt_global.h"
#include "qwt_interval.h"
 
#include <qvector.h>
#include <qrect.h>
 
class QWT_EXPORT QwtStatisticalSample
{
public:
    QwtStatisticalSample(double position = 0.0);
    
    double position;
    
    double lower;
    
    double upper;
    
    double center;
};
 
inline QwtStatisticalSample::QwtStatisticalSample(double pos)
    : position(pos)
    , lower(0.0)
    , upper(0.0)
    , center(0.0)
{
}
 
class QWT_EXPORT QwtIntervalSample
{
public:
    QwtIntervalSample();
    QwtIntervalSample(double, const QwtInterval&);
    QwtIntervalSample(double value, double min, double max);
 
    bool operator==(const QwtIntervalSample&) const;
    bool operator!=(const QwtIntervalSample&) const;
 
    double value;
 
    QwtInterval interval;
};
 
inline QwtIntervalSample::QwtIntervalSample() : value(0.0)
{
}
 
inline QwtIntervalSample::QwtIntervalSample(double v, const QwtInterval& intv) : value(v), interval(intv)
{
}
 
inline QwtIntervalSample::QwtIntervalSample(double v, double min, double max) : value(v), interval(min, max)
{
}
 
inline bool QwtIntervalSample::operator==(const QwtIntervalSample& other) const
{
    return value == other.value && interval == other.interval;
}
 
inline bool QwtIntervalSample::operator!=(const QwtIntervalSample& other) const
{
    return !(*this == other);
}
 
class QWT_EXPORT QwtSetSample
{
public:
    QwtSetSample();
    explicit QwtSetSample(double, const QVector< double >& = QVector< double >());
 
    bool operator==(const QwtSetSample& other) const;
    bool operator!=(const QwtSetSample& other) const;
 
    double added() const;
 
    double value;
 
    QVector< double > set;
};
 
inline QwtSetSample::QwtSetSample() : value(0.0)
{
}
 
inline QwtSetSample::QwtSetSample(double v, const QVector< double >& s) : value(v), set(s)
{
}
 
inline bool QwtSetSample::operator==(const QwtSetSample& other) const
{
    return value == other.value && set == other.set;
}
 
inline bool QwtSetSample::operator!=(const QwtSetSample& other) const
{
    return !(*this == other);
}
 
inline double QwtSetSample::added() const
{
    double y = 0.0;
    for (int i = 0; i < set.size(); i++)
        y += set[ i ];
 
    return y;
}
 
class QWT_EXPORT QwtOHLCSample
{
public:
    QwtOHLCSample(double time = 0.0, double open = 0.0, double high = 0.0, double low = 0.0, double close = 0.0);
 
    QwtInterval boundingInterval() const;
 
    bool isValid() const;
 
    double time;
 
    double open;
 
    double high;
 
    double low;
 
    double close;
};
 
inline QwtOHLCSample::QwtOHLCSample(double t, double o, double h, double l, double c)
    : time(t), open(o), high(h), low(l), close(c)
{
}
 
inline bool QwtOHLCSample::isValid() const
{
    return (low <= high) && (open >= low) && (open <= high) && (close >= low) && (close <= high);
}
 
inline QwtInterval QwtOHLCSample::boundingInterval() const
{
    double minY = open;
    minY        = qMin(minY, high);
    minY        = qMin(minY, low);
    minY        = qMin(minY, close);
 
    double maxY = open;
    maxY        = qMax(maxY, high);
    maxY        = qMax(maxY, low);
    maxY        = qMax(maxY, close);
 
    return QwtInterval(minY, maxY);
}
 
class QWT_EXPORT QwtVectorFieldSample
{
public:
    QwtVectorFieldSample(double x = 0.0, double y = 0.0, double vx = 0.0, double vy = 0.0);
 
    QwtVectorFieldSample(const QPointF& pos, double vx = 0.0, double vy = 0.0);
 
    QPointF pos() const;
 
    bool isNull() const;
 
    double x;
 
    double y;
 
    double vx;
 
    double vy;
};
 
inline QwtVectorFieldSample::QwtVectorFieldSample(double posX, double posY, double vectorX, double vectorY)
    : x(posX), y(posY), vx(vectorX), vy(vectorY)
{
}
 
inline QwtVectorFieldSample::QwtVectorFieldSample(const QPointF& pos, double vectorX, double vectorY)
    : x(pos.x()), y(pos.y()), vx(vectorX), vy(vectorY)
{
}
 
inline QPointF QwtVectorFieldSample::pos() const
{
    return QPointF(x, y);
}
 
inline bool QwtVectorFieldSample::isNull() const
{
    return (vx == 0.0) && (vy == 0.0);
}
 
class QWT_EXPORT QwtBoxSample : public QwtStatisticalSample
{
public:
    QwtBoxSample(double position = 0.0);
    
    QwtBoxSample(double position, double whiskerLower, double q1,
                 double median, double q3, double whiskerUpper);
    
    bool isValid() const;
    
    QwtInterval boundingInterval() const;
    
    QwtInterval boxInterval() const;
    
    double whiskerLower;
    
    double q1;
    
    double median;
    
    double q3;
    
    double whiskerUpper;
    
    int outlierCount;
};
 
inline QwtBoxSample::QwtBoxSample(double pos)
    : QwtStatisticalSample(pos)
    , whiskerLower(0.0)
    , q1(0.0)
    , median(0.0)
    , q3(0.0)
    , whiskerUpper(0.0)
    , outlierCount(0)
{
}
 
inline QwtBoxSample::QwtBoxSample(double pos, double wl, double q1v,
                                   double med, double q3v, double wu)
    : QwtStatisticalSample(pos)
    , whiskerLower(wl)
    , q1(q1v)
    , median(med)
    , q3(q3v)
    , whiskerUpper(wu)
    , outlierCount(0)
{
    center = median;
}
 
inline bool QwtBoxSample::isValid() const
{
    return (whiskerLower <= q1) && (q1 <= median) && 
           (median <= q3) && (q3 <= whiskerUpper);
}
 
inline QwtInterval QwtBoxSample::boundingInterval() const
{
    return QwtInterval(whiskerLower, whiskerUpper);
}
 
inline QwtInterval QwtBoxSample::boxInterval() const
{
    return QwtInterval(q1, q3);
}
 
class QWT_EXPORT QwtBoxOutlierSample
{
public:
    QwtBoxOutlierSample(double boxPosition = 0.0);
    
    QwtBoxOutlierSample(double boxPosition, const QVector<double>& values);
    
    QwtBoxOutlierSample(double boxPosition, QVector<double>&& values);
    
    bool isEmpty() const { return values.isEmpty(); }
    
    int count() const { return values.size(); }
    
    double boxPosition;
    
    QVector<double> values;
};
 
inline QwtBoxOutlierSample::QwtBoxOutlierSample(double pos)
    : boxPosition(pos)
    , values()
{
}
 
inline QwtBoxOutlierSample::QwtBoxOutlierSample(double pos, const QVector<double>& vals)
    : boxPosition(pos)
    , values(vals)
{
}
 
inline QwtBoxOutlierSample::QwtBoxOutlierSample(double pos, QVector<double>&& vals)
    : boxPosition(pos)
    , values(std::move(vals))
{
}
 
#endif