squeezing.h

Go to the documentation of this file.

#pragma once

/*+
________________________________________________________________________

 (C) dGB Beheer B.V.; (LICENSE) http://opendtect.org/OpendTect_license.txt
 Author:        Bert
 Date:          Aug 2010
________________________________________________________________________

-*/

#include "algomod.h"
#include "ranges.h"

template <class T>
mClass(Algo) DataSqueezer
{
public:

    inline      DataSqueezer( const Interval<T>& l )
                        : urg_(mUdf(T),mUdf(T))         { setRange(l,true); }
    void        setUntouchedRange( const Interval<T>& r ) { setRange(r,false); }

    inline      DataSqueezer( T l0, T l1 ) : urg_(mUdf(T),mUdf(T))      
                                        { setRange(Interval<T>(l0,l1),true); }
    void        setUntouchedRange( T u0, T u1 )
                                        { setRange(Interval<T>(u0,u1),false); }

    T           value(T) const;

    const Interval<T>&  range( bool lim ) const         { return lim?rg_:urg_; }
    void        setRange(const Interval<T>&,bool lim);

protected:

    Interval<T> rg_;
    Interval<T> urg_;
    bool        udfstart_, udfstop_;
    bool        udfustart_, udfustop_;

};


template <class T> 
inline void DataSqueezer<T>::setRange( const Interval<T>& inprg, bool lim )
{
    Interval<T>& rg = lim ? rg_ : urg_;
    rg = inprg;
    if ( !mIsUdf(rg.start) && !mIsUdf(rg.stop) )
        rg.sort(true);

    udfstart_ = mIsUdf(rg_.start); udfstop_ = mIsUdf(rg_.stop);
    udfustart_ = mIsUdf(urg_.start); udfustop_ = mIsUdf(urg_.stop);
    if ( !udfstart_ && !udfustart_ && urg_.start <= rg_.start )
        { urg_.start = mUdf(T); udfustart_ = true; }
    if ( !udfstop_ && !udfustop_ && urg_.stop >= rg_.stop )
        { urg_.stop = mUdf(T); udfustop_ = true; }
}


template <class T> 
inline T DataSqueezer<T>::value( T v ) const
{
    if ( mIsUdf(v) ) return v;

    if ( !udfstart_  )
    {
        if ( udfustart_ )
        {
            if ( v < rg_.start )
                v = rg_.start;
        }
        else if ( v < urg_.start )
        {
            const T w = rg_.start - urg_.start;
            v = rg_.start - ((w*w) / (v + w - urg_.start));
        }
    }
    if ( !udfstop_  )
    {
        if ( udfustop_ )
        {
            if ( v > rg_.stop )
                v = rg_.stop;
        }
        else if ( v > urg_.stop )
        {
            const T w = rg_.stop - urg_.stop;
            v = rg_.stop - ((w*w) / (v + w - urg_.stop));
        }
    }

    return v;
}