samplfunc.h

Go to the documentation of this file.

#pragma once

/*+
________________________________________________________________________

 (C) dGB Beheer B.V.; (LICENSE) http://opendtect.org/OpendTect_license.txt
 Author:        Kristofer Tingdahl
 Date:          07-10-1999
________________________________________________________________________

-*/

#include "mathfunc.h"
#include "periodicvalue.h"

template <class RT,class T>
mClass(Algo) SampledFunction : public MathFunction<RT,RT>
{
public:
                                SampledFunction( bool periodic_= false )
                                    : periodic( periodic_ ) {}

    virtual RT                  operator[](od_int64)    const           = 0;

    virtual float               getDx() const                           = 0;
    virtual float               getX0() const                           = 0;

    virtual int                 size() const                            = 0;

    virtual float               period() const { return mUdf(float); } 
    void                        setPeriodic( bool np ) { periodic = np; } 

    float                       getIndex(float x) const
                                    { return (x-getX0()) / getDx(); }

    int                         getNearestIndex(float x) const
                                    { return mNINT32(getIndex( x )); }

    RT                          getValue( RT x ) const
                                { 
                                    if ( !doInterpolate() )
                                    {
                                        const int smpl = mNINT32( getIndex(x) );
                                        if ( smpl<0 || smpl>=size() )
                                            return mUdf(RT);
                                        return (*this)[smpl];
                                    }

                                    if ( periodic )
                                    {
                                        return 
                                            IdxAble::interpolateYPeriodicReg(
                                                    *this, size(),
                                                    getIndex(x), period(),
                                                    extrapolate());
                                    }

                                    return hasUdfs() 
                                        ? IdxAble::interpolateRegWithUdf( *this,
                                                size(), getIndex(x),
                                                extrapolate())
                                        : IdxAble::interpolateReg( *this,
                                                size(), getIndex(x),
                                                extrapolate());
                                }

    RT                          getValue( const RT* x ) const
                                { return getValue(*x); }

protected:
    bool                        periodic;


    virtual bool                extrapolate() const { return false; }
    virtual bool                hasUdfs() const { return false; }
    virtual bool                doInterpolate() const { return true; }
};


template <class RT, class T>
mClass(Algo) SampledFunctionImpl : public SampledFunction<RT,T>
{
public:
                        SampledFunctionImpl(const T& idxabl,int sz,
                            float x0=0,float dx=1 )
                            : idxabl_( idxabl )
                            , sz_( sz )
                            , x0_( x0 )
                            , dx_( dx )
                            , period_ ( mUdf(float) )
                            , hasudfs_( false )
                            , interpolate_( true )
                        {}

    RT                  operator[](od_int64 idx) const  { return idxabl_[idx];}

    float               getDx() const                   { return dx_; }
    float               getX0() const                   { return x0_; }

    int                 size() const                    { return sz_; }

    float               period() const                  { return period_; }
    void                setPeriod(float np)             { period_ = np; }

    bool                hasUdfs() const                 { return hasudfs_; }
    void                setHasUdfs(bool yn)             { hasudfs_=yn; }

    bool                doInterpolate() const           { return interpolate_; }
    void                setInterpolate( bool yn )       { interpolate_=yn; }

protected:

    const T&            idxabl_;
    int                 sz_;
    int                 firstidx_;

    float               dx_;
    float               x0_;

    float               period_;
    bool                hasudfs_;
    bool                interpolate_;
};