seisdatapack.h

Go to the documentation of this file.

#pragma once
 
/*+
________________________________________________________________________
 
 (C) dGB Beheer B.V.; (LICENSE) http://opendtect.org/OpendTect_license.txt
 Author:        Mahant Mothey
 Date:          February 2015
 RCS:           $Id: seisdatapack.h 38554 2015-03-18 09:20:03Z mahant.mothey@dgbes.com $
________________________________________________________________________
 
-*/
 
#include "seismod.h"
 
#include "datapackbase.h"
#include "trckeyzsampling.h"
#include "seisinfo.h"
 
class BinIDValueSet;
class TraceData;
namespace PosInfo { class CubeData; }
 
mExpClass(Seis) RegularSeisDataPack : public SeisDataPack
{
public:
                                RegularSeisDataPack(const char* cat,
                                                    const BinDataDesc* bdd=0);
                                ~RegularSeisDataPack();
 
    RegularSeisDataPack*        clone() const;
    RegularSeisDataPack*        getSimilar() const;
    bool                        copyFrom(const RegularSeisDataPack&);
 
    void                        setSampling( const TrcKeyZSampling& tkzs )
                                { sampling_ = tkzs; }
    const TrcKeyZSampling&      sampling() const
                                { return sampling_; }
    StepInterval<float>         zRange() const  { return sampling_.zsamp_; }
 
    void                        setTrcsSampling(PosInfo::CubeData*);
    const PosInfo::CubeData*    getTrcsSampling() const;
    bool                        is2D() const;
 
    bool                        addComponent(const char* nm);
    bool                        addComponentNoInit(const char* nm);
 
    int                         nrTrcs() const
                                { return (int)sampling_.hsamp_.totalNr(); }
    TrcKey                      getTrcKey(int globaltrcidx) const;
    int                         getGlobalIdx(const TrcKey&) const;
 
    virtual void                dumpInfo(IOPar&) const;
 
    const StepInterval<float>&  getZRange() const
                                { return sampling_.zsamp_; }
 
    static DataPack::ID         createDataPackForZSlice(const BinIDValueSet*,
                                                const TrcKeyZSampling&,
                                                const ZDomain::Info&,
                                            const BufferStringSet* nms=nullptr);
    void                        fillTrace(const TrcKey&,SeisTrc&) const;
    void                        fillTraceInfo(const TrcKey&,SeisTrcInfo&) const;
    void                        fillTraceData(const TrcKey&,TraceData&) const;
 
protected:
 
    TrcKeyZSampling             sampling_;
    PosInfo::CubeData*          rgldpckposinfo_;
};
 
 
mExpClass(Seis) RandomSeisDataPack : public SeisDataPack
{
public:
                                RandomSeisDataPack(const char* cat,
                                                   const BinDataDesc* bdd=0);
 
    bool                        is2D() const            { return false; }
    int                         nrTrcs() const          { return path_.size(); }
    TrcKey                      getTrcKey(int trcidx) const;
    int                         getGlobalIdx(const TrcKey&) const;
 
    const StepInterval<float>&  getZRange() const       { return zsamp_; }
    void                        setZRange( const StepInterval<float>& zrg )
                                { zsamp_ = zrg; }
 
    void                        setPath( const TrcKeyPath& path )
                                { path_ = path; }
    const TrcKeyPath&           getPath() const         { return path_; }
 
    bool                        addComponent(const char* nm);
 
    static DataPack::ID         createDataPackFrom(const RegularSeisDataPack&,
                                                   const TrcKeyPath& path,
                                                   const Interval<float>& zrg);
 
protected:
 
    TrcKeyPath                  path_;
    StepInterval<float>         zsamp_;
 
public:
    static DataPack::ID         createDataPackFrom(const RegularSeisDataPack&,
                                                   int rdmlineid,
                                                   const Interval<float>& zrg);
 
    static DataPack::ID         createDataPackFrom(const RegularSeisDataPack&,
                                               int rdmlineid,
                                               const Interval<float>& zrg,
                                               const BufferStringSet* nms);
 
    static DataPack::ID         createDataPackFrom(const RegularSeisDataPack&,
                                               const TrcKeyPath& path,
                                               const Interval<float>& zrg,
                                               const BufferStringSet* nms);
 
    TrcKeyPath&                 getPath()               { return path_; }
};
 
 
mExpClass(Seis) SeisFlatDataPack : public FlatDataPack
{
public:
                                ~SeisFlatDataPack();
 
    int                         nrTrcs() const
                                { return source_.nrTrcs(); }
    TrcKey                      getTrcKey( int trcidx ) const
                                { return source_.getTrcKey(trcidx); }
    const SeisDataPack&         getSourceDataPack() const
                                { return source_; }
    bool                        is2D() const
                                { return source_.is2D(); }
 
    virtual bool                isVertical() const                      = 0;
    virtual const TrcKeyPath&   getPath() const                         = 0;
    const StepInterval<float>&  getZRange() const       { return zsamp_; }
 
    bool                        dimValuesInInt(const char* keystr) const;
    void                        getAltDim0Keys(BufferStringSet&) const;
    double                      getAltDim0Value(int ikey,int i0) const;
    void                        getAuxInfo(int i0,int i1,IOPar&) const;
 
    const Scaler*               getScaler() const
                                { return source_.getScaler(); }
    const ZDomain::Info&        zDomain() const
                                { return source_.zDomain(); }
    float                       nrKBytes() const;
    int                         getRandomLineID() const;
 
protected:
 
                                SeisFlatDataPack(const SeisDataPack&,int comp);
 
    virtual void                setSourceData()                         = 0;
    virtual void                setTrcInfoFlds()                        = 0;
    void                        setPosData();
    const SeisDataPack&         source_;
    int                         comp_;
    const StepInterval<float>&  zsamp_;
 
    TypeSet<SeisTrcInfo::Fld>   tiflds_;
    int                         rdlid_;
};
 
 
mExpClass(Seis) RegularFlatDataPack : public SeisFlatDataPack
{
public:
                                RegularFlatDataPack(const RegularSeisDataPack&,
                                                    int component);
 
    bool                        isVertical() const
                                { return dir_ != TrcKeyZSampling::Z; }
    const TrcKeyPath&           getPath() const         { return path_; }
    float                       getPosDistance(bool dim0,float trcfidx) const;
 
    const TrcKeyZSampling&      sampling() const        { return sampling_; }
    Coord3                      getCoord(int i0,int i1) const;
 
    const char*                 dimName(bool dim0) const;
 
protected:
 
    void                        setSourceDataFromMultiCubes();
    void                        setSourceData();
    void                        setTrcInfoFlds();
 
    TrcKeyPath                  path_;
    const TrcKeyZSampling&      sampling_;
    TrcKeyZSampling::Dir        dir_;
    bool                        usemulticomps_;
    bool                        hassingletrace_;
};
 
 
mExpClass(Seis) RandomFlatDataPack : public SeisFlatDataPack
{
public:
                                RandomFlatDataPack(const RandomSeisDataPack&,
                                                   int component);
 
    bool                        isVertical() const      { return true; }
    const TrcKeyPath&           getPath() const         { return path_; }
    Coord3                      getCoord(int i0,int i1) const;
    float                       getPosDistance(bool dim0,float trcfidx) const;
 
    const char*                 dimName( bool dim0 ) const
                                { return dim0 ? "Distance" : "Z"; }
 
protected:
 
    void                        setSourceData();
    void                        setRegularizedPosData();
    void                        setTrcInfoFlds();
    const TrcKeyPath&           path_;
};