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
 RCS:           $Id$
________________________________________________________________________
 
-*/
 
#include "seismod.h"
#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                setAll(float,int icomp=-1);
    void                setNrComponents(int,DataCharacteristics::UserType dt
                                        =DataCharacteristics::Auto);
    bool                reSize(int,bool copydata);
    void                copyDataFrom(const SeisTrc&,int icomp=-1,
                                     bool forcefloats=false);
 
    static const float  snapdist; 
 
    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 StepInterval<float> zRange() const
                        { return StepInterval<float>(startPos(),endPos(),
                                        info_.sampling.step ); }
    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_ ); }