prestackprocessor.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:          April 2005
 RCS:           $Id$
________________________________________________________________________
 
 
-*/
 
#include "prestackprocessingmod.h"
#include "bufstringset.h"
#include "datapack.h"
#include "factory.h"
#include "keystrs.h"
#include "paralleltask.h"
#include "position.h"
#include "sets.h"
#include "trckeysampling.h"
 
namespace PreStack
{
 
class Gather;
 
mExpClass(PreStackProcessing) Processor : public ParallelTask
{
public:
                                mDefineFactoryInClass( Processor, factory );
 
    virtual bool                reset(bool force=true);
 
    virtual const BinID&        getInputStepout() const;
    virtual bool                wantsInput(const BinID& relbid) const;
    void                        setInput(const BinID& relbid,DataPack::ID);
 
    const BinID&                getOutputStepout() const;
    virtual bool                setOutputInterest(const BinID& relbid,bool);
    bool                        getOutputInterest(const BinID& relbid) const;
    DataPack::ID                getOutput(const BinID& relbid) const;
 
    virtual bool                prepareWork();
    virtual uiString            errMsg() const 
                                { return uiString::emptyString(); }
 
    virtual void                fillPar(IOPar&) const                   = 0;
    virtual bool                usePar(const IOPar&)                    = 0;
    virtual bool                doWork(od_int64 start,od_int64 stop,int)= 0;
    int                         nrOffsets() const;
    virtual od_int64            nrIterations() const { return nrOffsets(); }
    virtual                     ~Processor();
    virtual bool                usesPreStackInput() const       { return true; }
    virtual void                adjustPossibleCompArea(TrcKeySampling&){return;}
    virtual void                retainCurBID( const BinID& ) {};
    virtual bool                mustHaveUserInput() { return true; }
 
protected:
                                Processor( const char* nm );
    virtual Gather*             createOutputArray(const Gather& input) const;
    static int                  getRelBidOffset(const BinID& relbid,
                                                const BinID& stepout);
    static void                 freeArray(ObjectSet<Gather>&);
 
    BinID                       outputstepout_;
    ObjectSet<Gather>           outputs_;
    BoolTypeSet                 outputinterest_;
 
    ObjectSet<Gather>           inputs_;
};
 
 
mExpClass(PreStackProcessing) ProcessManager : public CallBacker
{ mODTextTranslationClass(ProcessManager)
public:
                                ProcessManager();
                                ~ProcessManager();
 
                                //Setup
    int                         nrProcessors() const;
    Processor*                  getProcessor(int);
    const Processor*            getProcessor(int) const;
    bool                        needsPreStackInput() const;
 
 
    void                        addProcessor(Processor*);
    void                        removeProcessor(int);
    void                        swapProcessors(int,int);
    int                         indexOf(const Processor*) const;
 
    void                        removeAllProcessors();
 
    void                        notifyChange()  { setupChange.trigger(); }
    Notifier<ProcessManager>    setupChange;
 
                                //Runtime
    bool                        reset(bool force=true);
    bool                        prepareWork();
    BinID                       getInputStepout() const;
    virtual bool                wantsInput(const BinID& relbid) const;
    void                        setInput(const BinID& relbid,DataPack::ID);
 
    bool                        process();
 
    DataPack::ID                getOutput() const;
 
    void                        fillPar(IOPar&) const;
    bool                        usePar(const IOPar&);
 
    uiString                    errMsg() const  { return errmsg_; }
 
    //Keys for od_process_prestack
    static const char*          sKeyLineKey()   { return sKey::LineKey(); }
    static const char*          sKeySetup(){ return "Processing Setup"; }
    static const char*          sKeyCDPRange(){ return "CDP Range"; }
    static const char*          sKeyInputData() { return "Input"; }
    static const char*          sKeyOutputData(){ return "Output"; }
 
 
protected:
 
    static const char*  sKeyNrProcessors()      { return "Nr processors"; }
 
    ObjectSet<Processor>        processors_;
    uiString                    errmsg_;
};
 
 
#define mPSProcAddStepoutStep( array, arrtype, oldstepout, newstepout ) \
{ \
    arrtype arrcopy( array ); \
    array.erase(); \
\
    for ( int idx=-newstepout.inl(); idx<=newstepout.inl(); idx++ ) \
    { \
        for ( int idy=-newstepout.crl(); idy<=newstepout.crl(); idy++ ) \
        { \
            const BinID curpos( idx, idy ); \
\
            if ( idy<-oldstepout.crl() || idy>oldstepout.crl() || \
                idx<-oldstepout.inl() || idx>oldstepout.inl() ) \
            { \
                array += 0; \
            } \
            else \
            { \
                const int oldoffset=getRelBidOffset(curpos,oldstepout);\
                array += arrcopy[oldoffset]; \
            } \
        } \
    } \
}
 
} // namespace PreStack