Generated/html/attribprovider_8h_source.html

#pragma once


/*+

________________________________________________________________________


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

 Author:        Kristofer Tingdahl

 Date:          07-10-1999

 RCS:           $Id$

________________________________________________________________________


-*/


#include "attributeenginemod.h"

#include "linekey.h"

#include "ranges.h"

#include "posinfo2dsurv.h"

#include "uistring.h"


class BinDataDesc;

class RegularSeisDataPack;

class SeisMSCProvider;

class SeisTrcInfo;

namespace Seis { class SelData; }

template <class T> class Array2DImpl;


#define mMAXDIP 300 * 1e-6

#define mMAXDIPSECURE 2000 * 1e-6

#define mMAXDIPSECUREDEPTH 6


namespace Attrib

{


class DataHolder;

class DataHolderLineBuffer;

class Desc;

class ProviderTask;


mExpClass(AttributeEngine) Provider

{ mRefCountImpl(Provider);

  mODTextTranslationClass(Attrib::Provider)


    friend class                ProviderTask;


public:


    static Provider*            create(Desc&,uiString& errmsg);

    virtual bool                isOK() const;

    bool                        is2D() const;


    const Desc&                 getDesc() const;

    Desc&                       getDesc();

    const DataHolder*           getData(const BinID& relpos=BinID(0,0),

                                        int idx=0);

    const DataHolder*           getDataDontCompute(const BinID& relpos) const;


    int                         nrOutputs() const

                                { return outputinterest_.size(); }

    void                        enableOutput(int output,bool yn=true);

    bool                        isOutputEnabled(int output) const;

    void                        setOutputInterestSize(bool preserve=false);

    void                        enableAllOutputs(bool yn=true);

    virtual void                getCompNames(BufferStringSet&) const;

    virtual void                getCompOutputIDs(TypeSet<int>&) const;


    virtual bool                isSingleTrace() const;

    virtual bool                usesTracePosition() const;

    virtual void                setReqBufStepout(const BinID&,bool wait=false);

    virtual void                setDesBufStepout(const BinID&,bool wait=false);

    const BinID&                getReqBufStepout() const

                                { return reqbufferstepout_; }

    const BinID&                getDesBufStepout() const

                                { return desbufferstepout_; }

    void                        setDesiredVolume(const TrcKeyZSampling&);

    const TrcKeyZSampling*              getDesiredVolume() const

                                { return desiredvolume_; }

    void                        resetDesiredVolume();

    void                        setPossibleVolume(const TrcKeyZSampling&);

    virtual bool                getPossibleVolume(int outp,TrcKeyZSampling&);

    const TrcKeyZSampling*              getPossibleVolume() const

                                { return possiblevolume_; }

    int                         getTotalNrPos(bool);

    void                        setCurLineName(const char*);

    virtual void                adjust2DLineStoredVolume();

    virtual Pos::GeomID         getGeomID() const;

    virtual void                setGeomID(Pos::GeomID);


    virtual int                 moveToNextTrace(BinID startpos = BinID(-1,-1),

                                                bool firstcheck = false);

    void                        computeNewStartPos(BinID&);

    int                         alignInputs(ObjectSet<Provider>&);

    int                         comparePosAndAlign(Provider*,bool,Provider*,

                                                   bool,bool);

    void                        resetMoved();

    void                        resetZIntervals();


    virtual const SeisTrcInfo*  getCurrentTrcInfo() const {return curtrcinfo_;}

    BinID                       getCurrentPosition() const;

    virtual bool                setCurrentPosition(const BinID&);

    Coord                       getCurrentCoord() const;

    Coord                       getCoord(const BinID&) const;

    void                        updateCurrentInfo();

    virtual bool                needStoredInput() const;


    void                        addLocalCompZIntervals(

                                                const TypeSet<Interval<int> >&);

    const TypeSet< Interval<int> >&     localCompZIntervals() const;


    void                        updateInputReqs(int input=-1);

    virtual void                updateStorageReqs(bool all=false);

    void                        setUseSC()              { useshortcuts_ = true;}

    void                        setSelData(const Seis::SelData*);

    void                        setExtraZ(const Interval<float>&);

    void                        setNeedInterpol(bool);

    void                        setExactZ(const TypeSet<float>&);


    void                        computeRefStep();

    void                        setRefStep(float step);

    float                       getRefStep() const;


    void                        computeRefZ0();

    void                        setRefZ0(float z0);

    float                       getRefZ0() const        { return refz0_; }


    virtual BinID               getStepoutStep() const;

    ObjectSet<Provider>&        getInputs()             { return inputs_; }

    BinID                       getTrcInfoBid() const   { return trcinfobid_; }

    uiString                    errMsg() const;


    virtual void                initSteering()                          {}

    virtual void                prepSteeringForStepout(const BinID&)    {}


    virtual bool                prepPriorToOutputSetup();

    virtual void                prepPriorToBoundsCalc();

    virtual void                prepareForComputeData();

    static uiString             prepare(Desc&);

    virtual void                fillDataPackWithTrc(RegularSeisDataPack*) const

                                {}


    virtual void                setRdmPaths(TypeSet<BinID>* truepath,

                                            TypeSet<BinID>* snappedpath);


    virtual void                updateCSIfNeeded(TrcKeyZSampling&) const {}

    virtual bool                compDistBetwTrcsStats(bool force=false);

    float                       getApplicableCrlDist(bool) const;

    virtual float               getDistBetwTrcs(bool,

                                                const char* linenm =0) const;

    BinID                       getElementStepout() const;


protected:


                                Provider(Desc&);

    virtual bool                checkInpAndParsAtStart();

    virtual SeisMSCProvider*    getMSCProvider(bool&) const;

    static Provider*            internalCreate(Desc&,ObjectSet<Provider>&,

                                               bool& issame,uiString&);

    virtual bool                getInputOutput(int input,TypeSet<int>&) const;

    virtual bool                getInputData(const BinID& relpos,int idx);

    virtual bool                preProcCommonToAllThreads(const DataHolder& out,

                                                          const BinID& relpos)

                                { return true; }

    virtual bool                computeData(const DataHolder& output,

                                            const BinID& relpos,

                                            int t0,int nrsamples,

                                            int threadidx) const        = 0;

    int                         getDataIndex(int input) const;

    void                        fillInputRangesArray(

                                            Array2DImpl< BasicInterval<int> >&,

                                            int,const BasicInterval<int>&);


                                // MultiThreading stuff

    virtual bool                allowParallelComputation() const

                                { return false; }

    virtual bool                setNrThreads( int idx )         { return true; }

    virtual int                 minTaskSize() const             { return 25; }

    virtual bool                finalizeCalculation(bool scs)   { return scs; }

                                // DataHolder stuff

    DataHolder*                 getDataHolder(const BinID& relpos);

    void                        removeDataHolder(const BinID& relpos);

    void                        setInput(int input,Provider*);

    void                        addParent( Provider* prov ) { parents_+=prov; }

    virtual BinDataDesc         getOutputFormat(int output) const;

    virtual bool                doNotReUseDH() const            { return false;}


    void                        computeDesInputCube(int inp,int out,

                                                    TrcKeyZSampling&,

                                                    bool usestepout=true) const;

    void                        setUsedMultTimes();

    bool                        isUsedMultTimes()  { return isusedmulttimes_; }

    bool                        isNew2DLine() const

                                { return prevtrcnr_ > currentbid_.crl(); }


    virtual const BinID*        desStepout(int input,int output) const;

    virtual const BinID*        reqStepout(int input,int output) const;

    virtual const Interval<float>* desZMargin(int input,int output) const;

    virtual const Interval<float>* reqZMargin(int input,int output) const;

                                 /*<The gate is specified in

                                    the depth-unit of the survey (e.g. seconds,

                                    feet or meters), and is in addition to

                                    the gate specified in reqZSampMargin. The

                                    system will supply the attribute with the

                                    required gate, and use it to compute the

                                    volume that can be computed.

                                    \returns the extra gate required on

                                    \a input if \a output is going to be

                                    computed, or NULL if no extra gate

                                    is required. */

    virtual const Interval<int>* desZSampMargin(int input,int output) const;

    virtual const Interval<int>* reqZSampMargin(int input,int output) const;

    virtual bool                getZStepStoredData( float& step ) const

                                { return false; }

    virtual bool                getZ0StoredData( float& z0 ) const

                                { return false; }


    float                       getInterpolInputValue(const DataHolder&,

                                                      int inputidx,

                                                      float zval) const;

    float                       getInterpolInputValue(const DataHolder&,

                                                      int inputidx,float sample,

                                                      int z0) const;

    float                       getInputValue(const DataHolder&,int inputidx,

                                              int sampleidx,int z0) const;

    void                        setOutputValue(const DataHolder& output,

                                               int outputidx,int sampleidx,

                                               int z0,float val) const;

    float                       getExtraZFromSampPos(float) const;

    float                       getExtraZFromSampInterval(int,int) const;

    virtual bool                useInterTrcDist() const;

    float                       getZAtSample(int idx) const

                                { return refz0_ + idx*refstep_; }


    bool                        zIsTime() const;

    float                       zFactor() const;

    float                       dipFactor() const;

    float                       inlDist() const;

    float                       crlDist() const;

    float                       lineDist() const;

    float                       trcDist() const;

    float                       maxSecureDip() const

                                { return (float) (zIsTime() ? mMAXDIPSECURE

                                                   : mMAXDIPSECUREDEPTH); }

    void                        stdPrepSteering(const BinID&);


    ObjectSet<Provider>         inputs_;

    ObjectSet<Provider>         parents_;

    Desc&                       desc_;

    TypeSet<int>                outputinterest_;

    BinID                       desbufferstepout_;

    BinID                       reqbufferstepout_;

    TrcKeyZSampling*            desiredvolume_;

    TrcKeyZSampling*                    possiblevolume_;

    TypeSet< Interval<int> >    localcomputezintervals_;

    ObjectSet<Provider>         allexistingprov_;

    TypeSet<float>              exactz_;

                                // only used for outputs which require

                                // data at exact z values not placed

                                // at sample locations


    ProviderTask*               providertask_;

    DataHolderLineBuffer*       linebuffer_;

    BinID                       currentbid_;

    int                         prevtrcnr_;

    Pos::GeomID                 geomid_;

    const Seis::SelData*        seldata_;

    Interval<float>             extraz_;

    const SeisTrcInfo*          curtrcinfo_;

    BinID                       trcinfobid_;

    bool                        useshortcuts_;


    float                       refz0_;

    float                       refstep_;

    bool                        alreadymoved_;


    bool                        isusedmulttimes_;

    bool                        needinterp_;

    uiString                    errmsg_;

    bool                        dataunavailableflag_;


public:

    void                        setDataUnavailableFlag(bool yn);

    bool                        getDataUnavailableFlag() const;

};


mGlobal(AttributeEngine) int getSteeringIndex( const BinID& );


}; // namespace Attrib


#define mAttrDefCreateInstance(clss) \

Attrib::Provider* clss::createInstance( Attrib::Desc& desc ) \

{ \

    clss* res = new clss( desc ); \

    res->ref(); \

    if ( !res->isOK() ) \

    { \

        res->unRef(); \

        return 0; \

    } \

 \

    res->unRefNoDelete(); \

    return res; \

}


#define mAttrStartInitClass \

    Attrib::Desc* desc = new Attrib::Desc( attribName()); \

    desc->ref();


#define mAttrStartInitClassWithUpdate \

    Attrib::Desc* desc = new Attrib::Desc( attribName(), updateDesc ); \

    desc->ref();


#define mAttrStartInitClassWithDescAndDefaultsUpdate \

    Attrib::Desc* desc = new Attrib::Desc( attribName(), updateDesc,\

                                           updateDefaults ); \

    desc->ref();


#define mAttrStartInitClassWithDefaultsUpdate \

    Attrib::Desc* desc = new Attrib::Desc( attribName(), 0,updateDefaults ); \

    desc->ref();


#define mAttrEndInitClass \

    Attrib::PF().addDesc( desc, createInstance ); \

    desc->unRef();