qwt_interval.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_INTERVAL_H
#define QWT_INTERVAL_H
 
#include "qwt_global.h"
#include <qmetatype.h>
 
class QWT_EXPORT QwtInterval
{
public:
    enum BorderFlag
    {
        IncludeBorders = 0x00,
 
        ExcludeMinimum = 0x01,
 
        ExcludeMaximum = 0x02,
 
        ExcludeBorders = ExcludeMinimum | ExcludeMaximum
    };
 
    Q_DECLARE_FLAGS(BorderFlags, BorderFlag)
 
    QwtInterval();
    QwtInterval(double minValue, double maxValue, BorderFlags = IncludeBorders);
 
    // Assign the limits of the interval
    void setInterval(double minValue, double maxValue, BorderFlags = IncludeBorders);
 
    // Normalize the limits of the interval
    QwtInterval normalized() const;
    // Invert the interval
    QwtInterval inverted() const;
    // Limit the interval, keeping the border modes
    QwtInterval limited(double lowerBound, double upperBound) const;
 
    // Compare two intervals for equality
    bool operator==(const QwtInterval&) const;
    // Compare two intervals for inequality
    bool operator!=(const QwtInterval&) const;
 
    void setBorderFlags(BorderFlags);
    BorderFlags borderFlags() const;
 
    double minValue() const;
    double maxValue() const;
    double centerValue() const;
 
    double width() const;
    long double widthL() const;
 
    void setMinValue(double);
    void setMaxValue(double);
 
    // Test if a value is inside the interval
    bool contains(double value) const;
    // Test if an interval is inside the interval
    bool contains(const QwtInterval&) const;
 
    // Test if two intervals overlap
    bool intersects(const QwtInterval&) const;
    // Intersect two intervals
    QwtInterval intersect(const QwtInterval&) const;
    // Unite two intervals
    QwtInterval unite(const QwtInterval&) const;
 
    // Union of two intervals
    QwtInterval operator|(const QwtInterval&) const;
    // Intersection of two intervals
    QwtInterval operator&(const QwtInterval&) const;
 
    // Unite this interval with the given interval
    QwtInterval& operator|=(const QwtInterval&);
    // Intersect this interval with the given interval
    QwtInterval& operator&=(const QwtInterval&);
 
    // Extend the interval with a value
    QwtInterval extend(double value) const;
    // Extend an interval with a value
    QwtInterval operator|(double) const;
    // Extend an interval with a value
    QwtInterval& operator|=(double);
 
    bool isValid() const;
    bool isNull() const;
    void invalidate();
 
    // Symmetrize the interval around a value
    QwtInterval symmetrize(double value) const;
 
private:
    double m_minValue;
    double m_maxValue;
    BorderFlags m_borderFlags;
};
 
Q_DECLARE_OPERATORS_FOR_FLAGS(QwtInterval::BorderFlags)
Q_DECLARE_METATYPE(QwtInterval)
Q_DECLARE_TYPEINFO(QwtInterval, Q_MOVABLE_TYPE);
 
inline QwtInterval::QwtInterval() : m_minValue(0.0), m_maxValue(-1.0), m_borderFlags(IncludeBorders)
{
}
 
inline QwtInterval::QwtInterval(double minValue, double maxValue, BorderFlags borderFlags)
    : m_minValue(minValue), m_maxValue(maxValue), m_borderFlags(borderFlags)
{
}
 
inline void QwtInterval::setInterval(double minValue, double maxValue, BorderFlags borderFlags)
{
    m_minValue    = minValue;
    m_maxValue    = maxValue;
    m_borderFlags = borderFlags;
}
 
inline void QwtInterval::setBorderFlags(BorderFlags borderFlags)
{
    m_borderFlags = borderFlags;
}
 
inline QwtInterval::BorderFlags QwtInterval::borderFlags() const
{
    return m_borderFlags;
}
 
inline void QwtInterval::setMinValue(double minValue)
{
    m_minValue = minValue;
}
 
inline void QwtInterval::setMaxValue(double maxValue)
{
    m_maxValue = maxValue;
}
 
inline double QwtInterval::minValue() const
{
    return m_minValue;
}
 
inline double QwtInterval::maxValue() const
{
    return m_maxValue;
}
 
inline double QwtInterval::centerValue() const
{
    return isValid() ? (m_minValue + (m_maxValue - m_minValue) * 0.5) : 0.0;
}
inline bool QwtInterval::isValid() const
{
    if ((m_borderFlags & ExcludeBorders) == 0)
        return m_minValue <= m_maxValue;
    else
        return m_minValue < m_maxValue;
}
 
inline double QwtInterval::width() const
{
    return isValid() ? (m_maxValue - m_minValue) : 0.0;
}
 
inline long double QwtInterval::widthL() const
{
    if (!isValid())
        return 0.0;
 
    return static_cast< long double >(m_maxValue) - static_cast< long double >(m_minValue);
}
 
inline QwtInterval QwtInterval::operator&(const QwtInterval& other) const
{
    return intersect(other);
}
 
inline QwtInterval QwtInterval::operator|(const QwtInterval& other) const
{
    return unite(other);
}
 
inline bool QwtInterval::operator==(const QwtInterval& other) const
{
    return (m_minValue == other.m_minValue) && (m_maxValue == other.m_maxValue) && (m_borderFlags == other.m_borderFlags);
}
 
inline bool QwtInterval::operator!=(const QwtInterval& other) const
{
    return (!(*this == other));
}
 
inline QwtInterval QwtInterval::operator|(double value) const
{
    return extend(value);
}
 
inline bool QwtInterval::isNull() const
{
    return isValid() && m_minValue >= m_maxValue;
}
 
inline void QwtInterval::invalidate()
{
    m_minValue = 0.0;
    m_maxValue = -1.0;
}
 
#ifndef QT_NO_DEBUG_STREAM
QWT_EXPORT QDebug operator<<(QDebug, const QwtInterval&);
#endif
 
#endif