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 "qwtcore_global.h"
#include <qmetatype.h>
 
class QWTCORE_EXPORT QwtInterval
{
public:
    enum BorderFlag
    {
        IncludeBorders = 0x00,
 
        ExcludeMinimum = 0x01,
 
        ExcludeMaximum = 0x02,
 
        ExcludeBorders = ExcludeMinimum | ExcludeMaximum
    };
 
    Q_DECLARE_FLAGS(BorderFlags, BorderFlag)
 
    constexpr QwtInterval() noexcept;
    constexpr QwtInterval(double minValue, double maxValue, BorderFlags = IncludeBorders) noexcept;
 
    // Assign the limits of the interval
    void setInterval(double minValue, double maxValue, BorderFlags = IncludeBorders) noexcept;
 
    // 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) noexcept;
    constexpr BorderFlags borderFlags() const noexcept;
 
    constexpr double minValue() const noexcept;
    constexpr double maxValue() const noexcept;
    constexpr double centerValue() const noexcept;
 
    constexpr double width() const noexcept;
    constexpr long double widthL() const noexcept;
 
    void setMinValue(double) noexcept;
    void setMaxValue(double) noexcept;
 
    // 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);
 
    constexpr bool isValid() const noexcept;
    constexpr bool isNull() const noexcept;
    void invalidate() noexcept;
 
    // Symmetrize the interval around a value
    QwtInterval symmetrize(double value) const;
 
private:
    double m_minValue { 0.0 };
    double m_maxValue { -1.0 };
    BorderFlags m_borderFlags { IncludeBorders };
};
 
Q_DECLARE_OPERATORS_FOR_FLAGS(QwtInterval::BorderFlags)
Q_DECLARE_METATYPE(QwtInterval)
Q_DECLARE_TYPEINFO(QwtInterval, Q_MOVABLE_TYPE);
 
inline constexpr QwtInterval::QwtInterval() noexcept : m_minValue(0.0), m_maxValue(-1.0), m_borderFlags(IncludeBorders)
{
}
 
inline constexpr QwtInterval::QwtInterval(double minValue, double maxValue, BorderFlags borderFlags) noexcept
    : m_minValue(minValue), m_maxValue(maxValue), m_borderFlags(borderFlags)
{
}
 
inline void QwtInterval::setInterval(double minValue, double maxValue, BorderFlags borderFlags) noexcept
{
    m_minValue    = minValue;
    m_maxValue    = maxValue;
    m_borderFlags = borderFlags;
}
 
inline void QwtInterval::setBorderFlags(BorderFlags borderFlags) noexcept
{
    m_borderFlags = borderFlags;
}
 
inline constexpr QwtInterval::BorderFlags QwtInterval::borderFlags() const noexcept
{
    return m_borderFlags;
}
 
inline void QwtInterval::setMinValue(double minValue) noexcept
{
    m_minValue = minValue;
}
 
inline void QwtInterval::setMaxValue(double maxValue) noexcept
{
    m_maxValue = maxValue;
}
 
inline constexpr double QwtInterval::minValue() const noexcept
{
    return m_minValue;
}
 
inline constexpr double QwtInterval::maxValue() const noexcept
{
    return m_maxValue;
}
 
inline constexpr double QwtInterval::centerValue() const noexcept
{
    return isValid() ? (m_minValue + (m_maxValue - m_minValue) * 0.5) : 0.0;
}
inline constexpr bool QwtInterval::isValid() const noexcept
{
    return ((m_borderFlags & ExcludeBorders) == 0) ? (m_minValue <= m_maxValue) : (m_minValue < m_maxValue);
}
 
inline constexpr double QwtInterval::width() const noexcept
{
    return isValid() ? (m_maxValue - m_minValue) : 0.0;
}
 
inline constexpr long double QwtInterval::widthL() const noexcept
{
    return isValid() ? static_cast< long double >(m_maxValue) - static_cast< long double >(m_minValue) : 0.0L;
}
 
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 constexpr bool QwtInterval::isNull() const noexcept
{
    return isValid() && m_minValue >= m_maxValue;
}
 
inline void QwtInterval::invalidate() noexcept
{
    m_minValue = 0.0;
    m_maxValue = -1.0;
}
 
#ifndef QT_NO_DEBUG_STREAM
QWTCORE_EXPORT QDebug operator<<(QDebug, const QwtInterval&);
#endif
 
#endif