Generated/html/seistrctr_8h_source.html

#pragma once


/*+

________________________________________________________________________


 (C) dGB Beheer B.V.; (LICENSE) http://opendtect.org/OpendTect_license.txt

 Author:        A.H. Bril

 Date:          10-5-1995

 RCS:           $Id$

________________________________________________________________________


Translators for seismic traces.


-*/


#include "seismod.h"

#include "transl.h"

#include "ctxtioobj.h"

#include "samplingdata.h"

#include "basiccompinfo.h"

#include "seisinfo.h"

#include "seistype.h"

#include "linekey.h"


class SeisTrc;

class LinScaler;

class SeisTrcBuf;

class SeisTrcInfo;

class TraceData;

class TrcKeyZSampling;

class SeisPacketInfo;

class BufferStringSet;

namespace PosInfo       { class CubeData; }

namespace Seis          { class SelData; }


mExpClass(Seis) SeisTrcTranslatorGroup : public TranslatorGroup

{                               isTranslatorGroup(SeisTrc)

public:

                        mDefEmptyTranslatorGroupConstructor(SeisTrc)


    static const char*  sKeyDefault3D() { return "Cube"; }

    static const char*  sKeyDefault2D() { return "2D Cube"; }

    static const char*  sKeyDefaultAttrib() { return "Attribute"; }

    const char*         getSurveyDefaultKey(const IOObj*) const;

};


mExpClass(Seis) SeisTrcTranslator : public Translator

{ mODTextTranslationClass(SeisTrcTranslator);

public:


    mExpClass(Seis) ComponentData : public BasicComponentInfo

    {

        friend class    SeisTrcTranslator;


    protected:

                        ComponentData( const char* nm="Seismic Data" )

                        : BasicComponentInfo(nm)        {}

                        ComponentData( const ComponentData& cd )

                        : BasicComponentInfo(cd)        {}

                        ComponentData(const SeisTrc&,int icomp=0,

                                      const char* nm="Seismic Data");

        void            operator=(const ComponentData&);

    };


    mExpClass(Seis) TargetComponentData : public ComponentData

    {

        friend class    SeisTrcTranslator;


    public:


        int                     destidx;

        const ComponentData&    org;


    protected:


                            TargetComponentData( const ComponentData& c,

                                                 int idx )

                            : ComponentData(c), org(c), destidx(idx)    {}


        void            operator=(const TargetComponentData&);

    };


                        SeisTrcTranslator(const char*,const char*);

    virtual             ~SeisTrcTranslator();


    bool                initRead(Conn*,Seis::ReadMode rt=Seis::Prod);

    bool                initWrite(Conn*,const SeisTrc&);

    virtual Conn*       curConn()                       { return conn_; }


    SeisPacketInfo&             packetInfo()            { return pinfo_; }

    const Seis::SelData*        selData() const         { return seldata_; }

    ObjectSet<TargetComponentData>& componentInfo()     { return tarcds_; }

    const ObjectSet<TargetComponentData>&

                                componentInfo() const   { return tarcds_; }

    const ObjectSet<ComponentData>&

                                inputComponentData() const { return cds_; }

    const SamplingData<float>&  inpSD() const           { return insd_; }

    int                         inpNrSamples() const    { return innrsamples_; }

    const SamplingData<float>&  outSD() const           { return outsd_; }

    int                         outNrSamples() const    { return outnrsamples_;}


    void                setSelData( const Seis::SelData* t ) { seldata_ = t; }

    bool                commitSelections();

    virtual bool        readInfo(SeisTrcInfo&)          { return false; }

    virtual bool        read(SeisTrc&);

    virtual bool        skip( int nrtrcs=1 )            { return false; }

    virtual bool        write(const SeisTrc&);

                        // overrule if you don't need sorting/buffering


    virtual bool        close();

    uiString            errMsg() const                  { return errmsg_; }


    virtual bool        inlCrlSorted() const            { return true; }

    virtual int         bytesOverheadPerTrace() const   { return 240; }


    virtual void        usePar(const IOPar&);


    inline int          selComp( int nr=0 ) const       { return inpfor_[nr]; }

    inline int          nrSelComps() const              { return nrout_; }

    SeisTrc*            getEmpty();

    SeisTrc*            getFilled(const BinID&);

    virtual bool        supportsGoTo() const            { return false; }

    virtual bool        goTo(const BinID&)              { return false; }


    virtual void        cleanUp();


    static bool         getRanges(const MultiID&,TrcKeyZSampling&,

                                  const char* linekey=0);

    static bool         getRanges(const IOObj&,TrcKeyZSampling&,

                                  const char* linekey=0);


    virtual bool        getGeometryInfo(PosInfo::CubeData&) const

                                                        { return false; }


    static bool         is2D(const IOObj&,bool only_internal=false);

    static bool         isPS(const IOObj&);

    bool                isPS() const                    { return is_prestack; }

    static bool         isLineSet(const IOObj&);

    static const char*  sKeyIs2D();

    static const char*  sKeyIsPS();

    static const char*  sKeyRegWrite();

    static const char*  sKeySIWrite();


                        // Use the following fns only if you _really_ know

                        // what you're doing.

    void                enforceRegularWrite( bool yn )

                        { enforce_regular_write = yn; }

    void                enforceSurvinfoWrite( bool yn )

                        { enforce_survinfo_write = yn; }


    const LineKey&      curLineKey() const              { return curlinekey_; }

    void                setCurLineKey( const LineKey& lk ) { curlinekey_ = lk; }

    Pos::GeomID         curGeomID() const               { return geomid_; }

    void                setCurGeomID( Pos::GeomID gid ) { geomid_ = gid; }


    virtual bool        isUserSelectable(bool) const    { return false; }

    virtual int         estimatedNrTraces() const       { return -1; }


    void                setComponentNames(const BufferStringSet&);

    void                getComponentNames(BufferStringSet&) const;


    bool                haveWarnings() const;

    const BufferStringSet& warnings() const             { return warnings_; }


    const LinScaler*    traceScaler() const     { return curtrcscalebase_; }


protected:


    Conn*               conn_;

    SeisPacketInfo&     pinfo_;

    uiString            errmsg_;

    BufferStringSet*    compnms_;


    Seis::ReadMode      read_mode;

    bool                is_2d;

    bool                is_prestack;

    bool                enforce_regular_write;

    bool                enforce_survinfo_write;


    SamplingData<float>                 insd_;

    int                                 innrsamples_;

    ObjectSet<ComponentData>            cds_;

    ObjectSet<TargetComponentData>      tarcds_;

    const Seis::SelData*                seldata_;

    SamplingData<float>                 outsd_;

    int                                 outnrsamples_;

    Interval<int>                       samprg_;

    Pos::GeomID                         geomid_;

    LineKey                             curlinekey_;

    bool                                headerdonenew_;

    bool                                datareaddone_;

    TraceData*                          storbuf_;

    LinScaler*                          trcscalebase_;

    const LinScaler*                    curtrcscalebase_;


    virtual bool        forRead() const;

    void                addComp(const DataCharacteristics&,

                                const char* nm=0,int dtype=0);


    void                setDataType( int icomp, int d )

                        { cds_[icomp]->datatype = tarcds_[icomp]->datatype = d;}


                        /* Subclasses will need to implement the following: */

    virtual bool        initRead_()                     { return true; }

    virtual bool        initWrite_(const SeisTrc&)      { return true; }

    virtual bool        commitSelections_()             { return true; }

    virtual bool        readData(TraceData* extbuf=0)   { return false; }


                        // These are called from the default write()

    virtual bool        prepareWriteBlock(StepInterval<int>&,bool&)

                                                        { return true; }

    virtual bool        dumpBlock();

    virtual void        blockDumped(int nrtrcs)         {}

    virtual bool        writeTrc_(const SeisTrc&)       { return false; }

                        // Buffer to be written when writeBlock() is called

    SeisTrcBuf&         trcblock_;


    void                prepareComponents(SeisTrc&,int actualsz) const;


                        // Quick access to selected, like selComp() etc.

    ComponentData**     inpcds_;

    TargetComponentData** outcds_;


    TypeSet<int>        warnnrs_;

    BufferStringSet&    warnings_;

    virtual void        addWarn(int,const char*);


private:


    int*                inpfor_;

    int                 nrout_;

    int                 prevnr_;

    int                 lastinlwritten_;


    bool                initConn(Conn*);

    void                enforceBounds();

    bool                writeBlock();

    bool                copyDataToTrace(SeisTrc&);


    friend class SeisTrcReader;


public:


    void                setIs2D( bool yn )      { is_2d = yn; }

    void                setIsPS( bool yn )      { is_prestack = yn; }

    bool                readTraceData( TraceData* td=nullptr )

                        { return readData(td); }

};