seistrc.h

Go to the documentation of this file.

#pragma once

/*+
________________________________________________________________________

 (C) dGB Beheer B.V.; (LICENSE) http://opendtect.org/OpendTect_license.txt
 Author:        A.H. Bril
 Date:          10-5-1995
________________________________________________________________________

-*/

#include "seisinfo.h"
#include "tracedata.h"
#include "datachar.h"
#include "valseries.h"
#include "mathfunc.h"
#include "valseriesinterpol.h"

template <class T> class ValueSeriesInterpolator;
template <class T> class Array1D;

mExpClass(Seis) SeisTrc
{
public:

                        SeisTrc( int ns=0, const DataCharacteristics& dc
                                           = DataCharacteristics() )
                        : intpol_(0)
                                                { data_.addComponent(ns,dc); }
                        SeisTrc( const SeisTrc& t )
                        : intpol_(0)
                                                { *this = t; }
                        ~SeisTrc();
    SeisTrc&            operator =(const SeisTrc& t);
    inline bool         isEmpty() const         { return data_.isEmpty(); }

    SeisTrcInfo&        info()                  { return info_; }
    const SeisTrcInfo&  info() const            { return info_; }
    TraceData&          data()                  { return data_; }
    const TraceData&    data() const            { return data_; }
    int                 nrComponents() const    { return data_.nrComponents(); }

    inline void         set( int idx, float v, int icomp )
                        { data_.setValue( idx, v, icomp ); }
    inline float        get( int idx, int icomp ) const
                        { return data_.getValue(idx,icomp); }
    inline float        getFirst( int icomp=0 ) const
                        { return isEmpty() ? 0 : get(0,icomp); }
    inline float        getLast( int icomp=0 ) const
                        { return isEmpty() ? 0 : get(size()-1,icomp); }

    inline int          size() const
                        { return data_.size(0); }
    float               getValue(float,int icomp) const;

    bool                isNull(int icomp=-1) const;
    bool                hasUndef(int icomp=-1) const;
    inline void         zero( int icomp=-1 )
                        { data_.zero( icomp ); }
    void                addComponent( int ns=0,
                                      const DataCharacteristics& dc
                                                = DataCharacteristics(),
                                      bool cleardata=false )
                        { data_.addComponent( ns, dc, cleardata ); }
    void                removeComponent( int icomp )
                        { data_.delComponent( icomp ); }
    bool                reSize(int,bool copydata);
    void                erase()                 { reSize( 0, false); }
    void                copyDataFrom(const SeisTrc&,int icomp=-1,
                                     bool forcefloats=false);

    const ValueSeriesInterpolator<float>& interpolator() const;
    void                setInterpolator(ValueSeriesInterpolator<float>*);

    inline float        startPos() const
                        { return info_.sampling_.start; }
    inline float        endPos() const
                        { return info_.sampling_.atIndex( size()-1 ); }
    inline float        stepPos() const
                        { return info_.sampling_.step; }
    inline ZSampling    zRange() const
                        { return ZSampling(startPos(),endPos(),stepPos()); }
    inline float        samplePos( int idx ) const
                        { return info_.samplePos(idx); }
    inline int          nearestSample( float pos ) const
                        { return info_.nearestSample(pos); }
    void                setStartPos( float p )
                        { info_.sampling_.start = p; }
    inline bool         dataPresent( float t ) const
                        { return info_.dataPresent(t,size()); }
    SampleGate          sampleGate(const Interval<float>&,bool check) const;

    SeisTrc*            getRelTrc(const ZGate&,float sr=mUdf(float)) const;
    SeisTrc*            getExtendedTo(const ZGate&,bool usetrcvals=true) const;

    void                convertToFPs(bool preserve_data=true);

    static const char*  sKeyExtTrcToSI()
                        { return "Extend Traces To Survey Z Range"; }

protected:

    TraceData                                           data_;
    SeisTrcInfo                                         info_;
    mutable PtrMan<ValueSeriesInterpolator<float> >     intpol_;

    bool                chkForSpecVal(int icomp,bool isnull) const;

private:

    void                cleanUp();

};


mExpClass(Seis) SeisTrcValueSeries : public ValueSeries<float>
{
public:

                SeisTrcValueSeries( const SeisTrc& t, int c )
                    : trc_(const_cast<SeisTrc&>(t))
                    , icomp_(c)                 {}

    void        setComponent( int idx )         { icomp_ = idx; }
    float       value( od_int64 idx ) const;
    bool        writable() const                { return true; }
    void        setValue( od_int64 idx,float v);
    float*      arr();
    const float* arr() const;

    bool        copytoArray(Array1D<float>&);

    inline ValueSeries<float>*  clone() const;

protected:

    SeisTrc&    trc_;
    int         icomp_;
};

mExpClass(Seis) SeisTrcFunction : public FloatMathFunction
{
public:

                SeisTrcFunction(const SeisTrc& trc, int icomp)
                    : trc_(trc), icomp_(icomp)                  {}

    float       getValue( float z ) const { return trc_.getValue(z,icomp_); }
    float       getValue( const float* p ) const { return getValue(*p); }

protected:

    const SeisTrc&      trc_;
    const int           icomp_;
};

inline ValueSeries<float>* SeisTrcValueSeries::clone() const
{ return new SeisTrcValueSeries( trc_, icomp_ ); }