UT_SuperInterval.h

Go to the documentation of this file.

/*
 * PROPRIETARY INFORMATION.  This software is proprietary to
 * Side Effects Software Inc., and is not to be reproduced,
 * transmitted, or disclosed in any way without written permission.
 *
 * NAME:        UT_SuperInterval.h ( UT Library, C++)
 *
 * COMMENTS: This is an extension to UT_Interval which allows exclusive
 *           and inclusive ranges.
 */

#ifndef __UT_SuperInterval__
#define __UT_SuperInterval__

#include "UT_API.h"
#include "UT_Interval.h"
#include <SYS/SYS_Math.h>

template <typename T>
class UT_SuperIntervalT : public UT_IntervalT<T>
{
public:
    UT_SuperIntervalT()
        : UT_IntervalT<T>()
        , myMinInclusive(true)
        , myMaxInclusive(true)
    {
    }

    UT_SuperIntervalT(T a, T b, bool ia = true, bool ib = true)
        : UT_IntervalT<T>(a, b)
        , myMinInclusive(ia)
        , myMaxInclusive(ib)
    {
    }

    UT_SuperIntervalT(UT_IntervalT<T> const& interval)
        : UT_IntervalT<T>(interval)
        , myMinInclusive(true)
        , myMaxInclusive(true)
    {
    }
    UT_SuperIntervalT(UT_SuperIntervalT<T> const& interval)
        : UT_IntervalT<T>(interval)
        , myMinInclusive(interval.myMinInclusive)
        , myMaxInclusive(interval.myMaxInclusive)
    {
    }

    ~UT_SuperIntervalT() {}

    UT_SuperIntervalT &operator=(UT_SuperIntervalT<T> const& interval)
            = default;

    UT_SuperIntervalT &operator=( UT_IntervalT<T> const& interval )
    {
        if( this != &interval )
        {
            *(UT_IntervalT<T>*)this = interval;
            myMinInclusive = true;
            myMaxInclusive = true;
        }
        return *this;
    }

    // Returns true if arg is inside our interval range.
    // WARNING: This is masking the bool contains(T) function
    // defined by UT_Interval!
    bool        contains(T arg, T tol=T(SYS_FTOLERANCE) ) const
    {
        return
            (myMinInclusive ? 
                SYSisLessOrEqual(UT_IntervalT<T>::min, arg, tol) :
                SYSisLess(UT_IntervalT<T>::min, arg, tol) )
                &&
            (myMaxInclusive ?
                SYSisLessOrEqual(arg, UT_IntervalT<T>::max, tol) :
                SYSisLess(arg, UT_IntervalT<T>::max, tol) );
    }

    // Returns true if arg overlaps our interval range.
    // WARNING: This is masking the bool intersects(T) function
    // defined by UT_Interval!
    bool        intersects(const UT_SuperIntervalT &arg, T tol=T(SYS_FTOLERANCE)) const
    {
        const T max = UT_IntervalT<T>::max;
        const T min = UT_IntervalT<T>::min;

        if (SYSisLess(max, arg.min, tol))
            return false;

        if (SYSisEqual(max, arg.min, tol))
            return myMaxInclusive && arg.myMinInclusive;

        if (SYSisLess(arg.max, min, tol))
            return false;

        if (SYSisEqual(arg.max, min, tol))
            return arg.myMaxInclusive && myMinInclusive;

        return true;
    }

    // This adjusts the range of our own interval so it doesn't
    // exceed that of [c_min..c_max].  These boundaries are treated
    // as inclusive boundaries, and the interval is made inclusive
    // if clamped on an edge.
    void        clamp(T c_min, T c_max);

    void        display() const;

public:
    bool                myMinInclusive, myMaxInclusive;
};

typedef UT_SuperIntervalT<fpreal>       UT_SuperIntervalR;


//////////////////////////////////////////////////////////////////////////////
//
// Implementation
//

template <typename T>
void    
UT_SuperIntervalT<T>::clamp(T c_min, T c_max)
{
    if (UT_IntervalT<T>::min < c_min)
    {
        UT_IntervalT<T>::min = c_min;
        myMinInclusive = true;
    }
    if (UT_IntervalT<T>::max > c_max)
    {
        UT_IntervalT<T>::max = c_max;
        myMaxInclusive = true;
    }
}

#include <stdio.h>

template <typename T>
void
UT_SuperIntervalT<T>::display() const
{
    printf( "%c%g, %g%c",
        myMinInclusive ? '[' : '(',
        UT_IntervalT<T>::min,
        UT_IntervalT<T>::max,
        myMaxInclusive ? ']' : ')'
        );
}

#endif // __UT_SuperInterval__