qwt_interval.cpp

Go to the documentation of this file.

/******************************************************************************
 * 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
 *****************************************************************************/
 
#include "qwt_interval.h"
 
namespace
{
    static const struct RegisterQwtInterval
    {
        inline RegisterQwtInterval() { qRegisterMetaType< QwtInterval >(); }
 
    } qwtRegisterQwtInterval;
}
 
QwtInterval QwtInterval::normalized() const
{
    if ( m_minValue > m_maxValue )
    {
        return inverted();
    }
    if ( m_minValue == m_maxValue && m_borderFlags == ExcludeMinimum )
    {
        return inverted();
    }
 
    return *this;
}
 
QwtInterval QwtInterval::inverted() const
{
    BorderFlags borderFlags = IncludeBorders;
 
    if ( m_borderFlags & ExcludeMinimum )
        borderFlags |= ExcludeMaximum;
 
    if ( m_borderFlags & ExcludeMaximum )
        borderFlags |= ExcludeMinimum;
 
    return QwtInterval( m_maxValue, m_minValue, borderFlags );
}
 
bool QwtInterval::contains( double value ) const
{
    if ( !isValid() )
        return false;
 
    if ( ( value < m_minValue ) || ( value > m_maxValue ) )
        return false;
 
    if ( ( value == m_minValue ) && ( m_borderFlags & ExcludeMinimum ) )
        return false;
 
    if ( ( value == m_maxValue ) && ( m_borderFlags & ExcludeMaximum ) )
        return false;
 
    return true;
}
 
bool QwtInterval::contains( const QwtInterval& interval ) const
{
    if ( !isValid() || !interval.isValid() )
        return false;
 
    if ( ( interval.m_minValue < m_minValue ) || ( interval.m_maxValue > m_maxValue ) )
        return false;
 
    if ( m_borderFlags )
    {
        if ( interval.m_minValue == m_minValue )
        {
            if ( ( m_borderFlags & ExcludeMinimum )
                && !( interval.m_borderFlags & ExcludeMinimum ) )
            {
                return false;
            }
        }
 
        if ( interval.m_maxValue == m_maxValue )
        {
            if ( ( m_borderFlags & ExcludeMaximum )
                && !( interval.m_borderFlags & ExcludeMaximum ) )
            {
                return false;
            }
        }
    }
 
    return true;
}
 
QwtInterval QwtInterval::unite( const QwtInterval& other ) const
{
    /*
       If one of the intervals is invalid return the other one.
       If both are invalid return an invalid default interval
     */
    if ( !isValid() )
    {
        if ( !other.isValid() )
            return QwtInterval();
        else
            return other;
    }
    if ( !other.isValid() )
        return *this;
 
    QwtInterval united;
    BorderFlags flags = IncludeBorders;
 
    // minimum
    if ( m_minValue < other.minValue() )
    {
        united.setMinValue( m_minValue );
        flags &= m_borderFlags & ExcludeMinimum;
    }
    else if ( other.minValue() < m_minValue )
    {
        united.setMinValue( other.minValue() );
        flags &= other.borderFlags() & ExcludeMinimum;
    }
    else // m_minValue == other.minValue()
    {
        united.setMinValue( m_minValue );
        flags &= ( m_borderFlags & other.borderFlags() ) & ExcludeMinimum;
    }
 
    // maximum
    if ( m_maxValue > other.maxValue() )
    {
        united.setMaxValue( m_maxValue );
        flags &= m_borderFlags & ExcludeMaximum;
    }
    else if ( other.maxValue() > m_maxValue )
    {
        united.setMaxValue( other.maxValue() );
        flags &= other.borderFlags() & ExcludeMaximum;
    }
    else // m_maxValue == other.maxValue() )
    {
        united.setMaxValue( m_maxValue );
        flags &= m_borderFlags & other.borderFlags() & ExcludeMaximum;
    }
 
    united.setBorderFlags( flags );
    return united;
}
 
QwtInterval QwtInterval::intersect( const QwtInterval& other ) const
{
    if ( !other.isValid() || !isValid() )
        return QwtInterval();
 
    QwtInterval i1 = *this;
    QwtInterval i2 = other;
 
    // swap i1/i2, so that the minimum of i1
    // is smaller then the minimum of i2
 
    if ( i1.minValue() > i2.minValue() )
    {
        qSwap( i1, i2 );
    }
    else if ( i1.minValue() == i2.minValue() )
    {
        if ( i1.borderFlags() & ExcludeMinimum )
            qSwap( i1, i2 );
    }
 
    if ( i1.maxValue() < i2.minValue() )
    {
        return QwtInterval();
    }
 
    if ( i1.maxValue() == i2.minValue() )
    {
        if ( i1.borderFlags() & ExcludeMaximum ||
            i2.borderFlags() & ExcludeMinimum )
        {
            return QwtInterval();
        }
    }
 
    QwtInterval intersected;
    BorderFlags flags = IncludeBorders;
 
    intersected.setMinValue( i2.minValue() );
    flags |= i2.borderFlags() & ExcludeMinimum;
 
    if ( i1.maxValue() < i2.maxValue() )
    {
        intersected.setMaxValue( i1.maxValue() );
        flags |= i1.borderFlags() & ExcludeMaximum;
    }
    else if ( i2.maxValue() < i1.maxValue() )
    {
        intersected.setMaxValue( i2.maxValue() );
        flags |= i2.borderFlags() & ExcludeMaximum;
    }
    else // i1.maxValue() == i2.maxValue()
    {
        intersected.setMaxValue( i1.maxValue() );
        flags |= i1.borderFlags() & i2.borderFlags() & ExcludeMaximum;
    }
 
    intersected.setBorderFlags( flags );
    return intersected;
}
 
QwtInterval& QwtInterval::operator|=( const QwtInterval& other )
{
    *this = *this | other;
    return *this;
}
 
QwtInterval& QwtInterval::operator&=( const QwtInterval& other )
{
    *this = *this & other;
    return *this;
}
 
bool QwtInterval::intersects( const QwtInterval& other ) const
{
    if ( !isValid() || !other.isValid() )
        return false;
 
    QwtInterval i1 = *this;
    QwtInterval i2 = other;
 
    // swap i1/i2, so that the minimum of i1
    // is smaller then the minimum of i2
 
    if ( i1.minValue() > i2.minValue() )
    {
        qSwap( i1, i2 );
    }
    else if ( i1.minValue() == i2.minValue() &&
        i1.borderFlags() & ExcludeMinimum )
    {
        qSwap( i1, i2 );
    }
 
    if ( i1.maxValue() > i2.minValue() )
    {
        return true;
    }
    if ( i1.maxValue() == i2.minValue() )
    {
        return !( ( i1.borderFlags() & ExcludeMaximum ) ||
               ( i2.borderFlags() & ExcludeMinimum ) );
    }
    return false;
}
 
QwtInterval QwtInterval::symmetrize( double value ) const
{
    if ( !isValid() )
        return *this;
 
    const double delta =
        qMax( qAbs( value - m_maxValue ), qAbs( value - m_minValue ) );
 
    return QwtInterval( value - delta, value + delta );
}
 
QwtInterval QwtInterval::limited( double lowerBound, double upperBound ) const
{
    if ( !isValid() || lowerBound > upperBound )
        return QwtInterval();
 
    double minValue = qMax( m_minValue, lowerBound );
    minValue = qMin( minValue, upperBound );
 
    double maxValue = qMax( m_maxValue, lowerBound );
    maxValue = qMin( maxValue, upperBound );
 
    return QwtInterval( minValue, maxValue, m_borderFlags );
}
 
QwtInterval QwtInterval::extend( double value ) const
{
    if ( !isValid() )
        return *this;
 
    return QwtInterval( qMin( value, m_minValue ),
        qMax( value, m_maxValue ), m_borderFlags );
}
 
QwtInterval& QwtInterval::operator|=( double value )
{
    *this = *this | value;
    return *this;
}
 
#ifndef QT_NO_DEBUG_STREAM
 
#include <qdebug.h>
 
QDebug operator<<( QDebug debug, const QwtInterval& interval )
{
    const int flags = interval.borderFlags();
 
    debug.nospace() << "QwtInterval("
                    << ( ( flags& QwtInterval::ExcludeMinimum ) ? "]" : "[" )
                    << interval.minValue() << "," << interval.maxValue()
                    << ( ( flags& QwtInterval::ExcludeMaximum ) ? "[" : "]" )
                    << ")";
 
    return debug.space();
}
 
#endif