seisparallelreader.h

Go to the documentation of this file.

#pragma once
/*
________________________________________________________________________
 
 (C) dGB Beheer B.V.; (LICENSE) http://opendtect.org/OpendTect_license.txt
 Author:        K. Tingdahl
 Date:          July 2010
 RCS:           $Id$
________________________________________________________________________
 
*/
 
#include "seismod.h"
 
#include "datachar.h"
#include "executor.h"
#include "fixedstring.h"
#include "paralleltask.h"
#include "sets.h"
#include "trckeyzsampling.h"
#include "uistring.h"
#include "valseriesinterpol.h"
 
class BinDataDesc;
class BinIDValueSet;
class IOObj;
class RegularSeisDataPack;
class Scaler;
class SeisTrc;
class SeisTrcBuf;
class SeisTrcReader;
class TraceData;
 
template <class T> class Array2D;
template <class T> class Array3D;
template <class T> class DataInterpreter;
namespace PosInfo { class CubeData; class CubeDataIterator; }
 
 
namespace Seis
{
 
class ObjectSummary;
class SelData;
 
mExpClass(Seis) ParallelReader : public ParallelTask
{ mODTextTranslationClass(ParallelReader)
public:
                        ParallelReader(const IOObj&,const TrcKeyZSampling&);
                        ParallelReader(const IOObj&,
                            BinIDValueSet&,
                            const TypeSet<int>& components);
                        ~ParallelReader();
 
    void                setComponents( const TypeSet<int>& compnrs )
                        { components_ = compnrs; }
    mDeprecatedDef bool setOutputComponents(const TypeSet<int>&);
    void                 setDataPack(RegularSeisDataPack*);
    RegularSeisDataPack* getDataPack();
 
    uiString            uiNrDoneText() const;
    uiString            uiMessage() const;
 
protected:
    od_int64            nrIterations() const { return totalnr_; }
 
    bool                setOutputComponents();
 
    bool                doPrepare(int nrthreads);
    bool                doWork(od_int64,od_int64,int);
    bool                doFinish(bool);
 
 
    TypeSet<int>                components_;
 
    BinIDValueSet*              bidvals_;
 
    RegularSeisDataPack*        dp_;
    TrcKeyZSampling             tkzs_;
    ObjectSet<TrcKeySampling>   tks_;
    PosInfo::CubeData* trcssampling_ = nullptr;
 
    IOObj*                      ioobj_;
    od_int64                    totalnr_;
 
    uiString                    errmsg_;
    TypeSet<int>                seisrdroutcompmgr_;
 
private:
 
    void                submitUdfWriterTasks();
};
 
 
mExpClass(Seis) ParallelReader2D : public ParallelTask
{ mODTextTranslationClass(ParallelReader2D)
public:
                        ParallelReader2D(const IOObj&,Pos::GeomID,
                                         const TrcKeyZSampling* =0,
                                         const TypeSet<int>* comps=0);
                        ~ParallelReader2D();
 
    void                setDataChar(DataCharacteristics::UserType);
    void                setScaler(Scaler*);
    bool                init();
 
    RegularSeisDataPack* getDataPack(); // The caller now owns the datapack
 
    uiString            uiNrDoneText() const;
    uiString            uiMessage() const;
 
protected:
    od_int64            nrIterations() const;
    bool                doPrepare(int nrthreads);
    bool                doWork(od_int64,od_int64,int);
    bool                doFinish(bool);
 
    RegularSeisDataPack*        dp_;
    TypeSet<int>                components_;
    TypeSet<int>        trcnrs_;
    TrcKeyZSampling             tkzs_;
    Pos::GeomID                 geomid_;
    IOObj*                      ioobj_;
    DataCharacteristics         dc_;
    Scaler*                     scaler_;
    od_int64                    totalnr_;
    uiString                    msg_;
 
    bool                        dpclaimed_;
};
 
 
mExpClass(Seis) SequentialReader : public Executor
{ mODTextTranslationClass(SequentialReader);
public:
                        SequentialReader(const IOObj&,
                                         const TrcKeyZSampling* =0,
                                         const TypeSet<int>* components=0);
                        ~SequentialReader();
 
    void                setComponents( const TypeSet<int>& compnrs )
                        { components_ = compnrs; }
    mDeprecatedDef bool setOutputComponents(const TypeSet<int>&);
    void                setComponentScaler(const Scaler&,int compidx);
    void                setDataChar(DataCharacteristics::UserType);
    void                setScaler(Scaler*);
 
    bool                setDataPack(RegularSeisDataPack&,od_ostream* strm=0);
    RegularSeisDataPack* getDataPack();
 
    uiString            uiMessage() const       { return msg_; }
    uiString            uiNrDoneText() const;
    od_int64            nrDone() const          { return nrdone_; }
    od_int64            totalNr() const         { return totalnr_; }
 
    bool                init();
 
protected:
 
    bool                setOutputComponents();
    virtual int         nextStep();
    virtual bool        goImpl(od_ostream*,bool,bool,int);
 
private:
 
    void                adjustDPDescToScalers(const BinDataDesc& trcdesc);
    bool                getTrcsPosForRead(int& desirednrpos,
                                          TypeSet<TrcKey>&) const;
    void                submitUdfWriterTasks();
 
    IOObj*                      ioobj_;
    bool                        is2d_;
    SeisTrcReader&              rdr_;
    RegularSeisDataPack*        dp_;
    TrcKeyZSampling             tkzs_;
    TypeSet<float>              refnrs_;
    TypeSet<int>                components_;
    Interval<int>               samprg_;
    PosInfo::CubeData*          trcssampling_;
    PosInfo::CubeDataIterator*  trcsiterator3d_;
    bool                        samedatachar_;
    StepInterval<float>         dpzsamp_;
    bool                        needresampling_;
    DataCharacteristics         dc_;
    Scaler*                     scaler_;
    ObjectSummary*              seissummary_;
 
    int                         queueid_;
 
    od_int64                    totalnr_;
    od_int64                    nrdone_;
    uiString                    msg_;
    bool                        initialized_;
    TypeSet<int>                outcomponents_;
    ObjectSet<Scaler>           compscalers_;
};
 
 
mExpClass(Seis) RawTrcsSequence
{ mODTextTranslationClass(Seis::RawTrcsSequence);
public:
                        RawTrcsSequence(const ObjectSummary&,int nrpos);
                        RawTrcsSequence(const RawTrcsSequence&);
                        ~RawTrcsSequence();
 
    RawTrcsSequence&    operator =(const RawTrcsSequence&);
 
    bool                isOK() const;
    bool                isPS() const;
    const DataCharacteristics   getDataChar() const;
 
    const StepInterval<float>&  getZRange() const;
    int                 nrPositions() const;
    float               get(int idx,int pos,int comp) const;
    float               getValue(float,int pos,int comp) const;
 
    void                set(int idx,float val,int pos,int comp);
    void                setPositions(const TypeSet<TrcKey>&); //Becomes mine
    void                setTrcScaler(int pos,const Scaler*);
    const Scaler*       getTrcScaler(int pos) const;
    void                copyFrom(const SeisTrc&,int* ipos=0);
    void                copyFrom(const SeisTrcBuf&)             {}
 
    //No checks
    const unsigned char* getData(int ipos,int icomp,int is=0) const;
    unsigned char*      getData(int ipos,int icomp,int is=0);
    const TrcKey&       getPosition(int ipos) const;
 
private:
 
    const ValueSeriesInterpolator<float>&       interpolator() const;
 
    ObjectSet<TraceData>        data_;
    const ObjectSummary&        info_;
    const TypeSet<TrcKey>*      tks_;
    const int                   nrpos_;
 
    mutable PtrMan<ValueSeriesInterpolator<float> >     intpol_;
 
public:
 
                // Special users only
 
    TraceData&          getTraceData( int pos ) { return *(data_[pos]); }
 
};
 
 
mExpClass(Seis) RawTrcsSequenceValueSeries : public ValueSeries<float>
{
public:
                        RawTrcsSequenceValueSeries(const RawTrcsSequence&,
                                                   int pos, int comp);
                        ~RawTrcsSequenceValueSeries();
 
    ValueSeries<float>* clone() const;
 
    inline void         setPosition( int pos )          { ipos_ = pos; }
    inline void         setComponent( int idx )         { icomp_ = idx; }
    void                setValue(od_int64,float);
    float*              arr();
 
    float               value(od_int64) const;
    bool                writable() const                { return true; }
    const float*        arr() const;
 
private:
 
    RawTrcsSequence&    seq_;
    int                 ipos_;
    int                 icomp_;
};
 
} // namespace Seis