undefarray.h

Go to the documentation of this file.

#pragma once
/*+
________________________________________________________________________
 
 (C) dGB Beheer B.V.; (LICENSE) http://opendtect.org/OpendTect_license.txt
 Author:        K. Tingdahl
 Date:          13/01/2005
 RCS:           $Id$
________________________________________________________________________
 
-*/
 
#include "algomod.h"
#include "commondefs.h"
#include "plftypes.h"
#include "ptrman.h"
#include "valseries.h"
 
class BinDataDesc;
 
template <class T> 
inline bool filterUndef(const T* input,T* output,int sz);
 
template <class T>
inline bool filterUndef(const ValueSeries<T>& input,ValueSeries<T>& output,int);
 
 
mExpClass(Algo) UndefArrayHandler
{
public:
                UndefArrayHandler(const BinDataDesc& desc);
    bool        set(const BinDataDesc& desc);
    bool        isOK() const;
 
    bool        isUdf(const void* ptr, od_int64 idx) const;
    void        setUdf(void* ptr, od_int64 idx) const;
    void        unSetUdf(void* ptr, od_int64 idx) const;
protected:
                typedef bool (*IsUdfFunc)(const void*,od_int64 idx);
                typedef void (*SetUdfFunc)(void*,od_int64 idx);
                typedef void (*UnsetUdfFunc)(void*,od_int64 idx);
 
    IsUdfFunc           isudf_;
    SetUdfFunc          setudf_;
    UnsetUdfFunc        limitrange_;
 
    static bool isUdfUChar(const void*,od_int64);
    static void setUdfUChar(void*,od_int64);
    static void unsetUdfUChar(void*,od_int64);
 
    static bool isUdfChar(const void*,od_int64);
    static void setUdfChar(void*,od_int64);
    static void unsetUdfChar(void*,od_int64);
 
    static bool isUdfUShort(const void*,od_int64);
    static void setUdfUShort(void*,od_int64);
    static void unsetUdfUShort(void*,od_int64);
 
    static bool isUdfShort(const void*,od_int64);
    static void setUdfShort(void*,od_int64);
    static void unsetUdfShort(void*,od_int64);
 
    static bool isUdfUInt32(const void*,od_int64);
    static void setUdfUInt32(void*,od_int64);
    static void unsetUdfUInt32(void*,od_int64);
 
    static bool isUdfInt32(const void*,od_int64);
    static void setUdfInt32(void*,od_int64);
    static void unsetUdfInt32(void*,od_int64);
 
    static bool isUdfUInt64(const void*,od_int64);
    static void setUdfUInt64(void*,od_int64);
    static void unsetUdfUInt64(void*,od_int64);
 
    static bool isUdfInt64(const void*,od_int64);
    static void setUdfInt64(void*,od_int64);
    static void unsetUdfInt64(void*,od_int64);
 
    static bool isUdfFloat(const void*,od_int64);
    static void setUdfFloat(void*,od_int64);
    static void unsetUdfFloat(void*,od_int64);
 
    static bool isUdfDouble(const void*,od_int64);
    static void setUdfDouble(void*,od_int64);
    static void unsetUdfDouble(void*,od_int64);
};
 
 
template <class T> inline
bool filterUndef( const ValueSeries<T>& input, T* outptr, int sz )
{
    if ( !sz || !outptr ) return true;
    
    const T* inptr = input.arr();
    
    ArrPtrMan<T> myinp = 0;
    if ( !inptr )
    {
        myinp = new T[sz];
        input.getValues( myinp, sz );
    }
    
    return filterUndef( inptr ? inptr : myinp, outptr, sz );
}
 
 
template <class T> inline
bool filterUndef( const ValueSeries<T>& input, ValueSeries<T>& output, int sz )
{
    if ( !sz ) return true;
 
    T* outptr = output.arr();
 
    ArrPtrMan<T> myoutp = 0;
    if ( !outptr )
        myoutp = outptr = new T[sz];
    
    if ( !filterUndef( input, outptr, sz ) )
        return false;
 
    if ( myoutp )
        output->setValues( outptr, sz );
 
    return true;
}
 
 
template <class T> inline
bool filterUndef(const T* input, T* output, int sz )
{
    if ( !sz )
        return true;
    
    int firstdefined = 0;
    while ( firstdefined<sz && mIsUdf(input[firstdefined]) )
        firstdefined++;
    
    if ( firstdefined==sz )
        return false;
    
    for ( int idx=0; idx<=firstdefined; idx++ )
        output[idx] = input[firstdefined];
    
    if ( firstdefined==sz-1 )
        return true;
    
    int prevdefined = firstdefined;
    int nextdefined = -1;
    
    for ( int idx=firstdefined+1; idx<sz; )
    {
        if ( !mIsUdf(input[idx]) )
        {
            prevdefined = idx;
            output[idx] = input[idx];
            idx++;
            
            continue;           
        }
 
        nextdefined = idx+1;
        while ( nextdefined<sz && mIsUdf(input[nextdefined]) )
            nextdefined++;
 
        idx = nextdefined;
 
        if ( nextdefined==sz )
        {
            for ( int posidx = prevdefined+1; posidx<sz; posidx++ )
                output[posidx] = input[prevdefined];
 
            return true;
        }
        else
        {
            const T diff = input[nextdefined] - input[prevdefined];
            const T unit = diff / (float)(nextdefined-prevdefined);
            for ( int posidx = prevdefined+1; posidx<=nextdefined; posidx++ )
                output[posidx] = input[prevdefined]+unit*(posidx-prevdefined);  
 
            prevdefined = nextdefined;
            nextdefined = -1;
        }
    }
 
    return true;
}