seistrctr.h

Go to the documentation of this file.

#ifndef seistrctr_h
#define seistrctr_h

/*+
________________________________________________________________________

 (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_; }

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; }
};


#endif