zaxistransform.h

Go to the documentation of this file.

#ifndef zaxistransform_h
#define zaxistransform_h
/*+
________________________________________________________________________

 (C) dGB Beheer B.V.; (LICENSE) http://opendtect.org/OpendTect_license.txt
 Author:        K. Tingdahl
 Date:          October 2006
 RCS:           $Id$
________________________________________________________________________

-*/

#include "algomod.h"
#include "enums.h"
#include "factory.h"
#include "binid.h"
#include "ranges.h"
#include "refcount.h"
#include "samplingdata.h"
#include "survgeom.h"

class BinIDValue;
class TrcKeyZSampling;
class TaskRunner;

namespace ZDomain { class Def; class Info; }

mExpClass(Algo) ZAxisTransform
{ mRefCountImpl(ZAxisTransform);
public:
                                mDefineFactoryInClass(ZAxisTransform,factory);

    static ZAxisTransform*      create(const IOPar&);
    virtual bool                isOK() const            { return true; }
    virtual uiString            errMsg() const          { return errmsg_; }

    virtual bool                needsVolumeOfInterest() const   { return true; }
    virtual int                 addVolumeOfInterest(const TrcKeyZSampling&,
                                                    bool zistrans=false);
    virtual void                setVolumeOfInterest(int volid,
                                                    const TrcKeyZSampling&,
                                                    bool zistrans=false);
    virtual void                removeVolumeOfInterest(int volid);

    virtual bool                loadDataIfMissing(int volid,TaskRunner* =0);

    virtual bool                canTransformSurv(Pos::SurvID) const =   0;

                                //Generic 2D and 3D
    virtual void                transformTrc(const TrcKey&,
                                          const SamplingData<float>&,
                                         int sz,float* res) const       = 0;
    float                       transformTrc(const TrcKey&,float z) const;
    virtual void                transformTrcBack(const TrcKey&,
                                          const SamplingData<float>&,
                                          int sz,float* res) const      = 0;
    float                       transformTrcBack(const TrcKey&,float z) const;

    virtual Interval<float>     getZInterval(bool from) const           = 0;
    virtual float               getZIntervalCenter(bool from) const;
    virtual float               getGoodZStep() const;
    ZDomain::Info&              fromZDomainInfo() { return fromzdomaininfo_; }
    ZDomain::Info&              toZDomainInfo()   { return tozdomaininfo_; }
    const ZDomain::Info&        fromZDomainInfo() const;
    const ZDomain::Info&        toZDomainInfo() const;
    const char*                 fromZDomainKey() const;
    const char*                 toZDomainKey() const;

    virtual float               toZScale() const;
    virtual float               zScale() const { return toZScale(); }
    virtual NotifierAccess*     changeNotifier()                { return 0; }
    virtual void                fillPar(IOPar&) const;
    virtual bool                usePar(const IOPar&);

protected:
                                ZAxisTransform(const ZDomain::Def& from,
                                               const ZDomain::Def& to);

    ZDomain::Info&              tozdomaininfo_;
    ZDomain::Info&              fromzdomaininfo_;
    mutable uiString            errmsg_;

public: //Legacy stuff

                                //3D
    virtual void                transform(const BinID&,
                                      const SamplingData<float>&,
                                      int sz,float* res) const;
    float                       transform(const BinIDValue&) const;
    float                       transform(const Coord3&) const;
    virtual void                transformBack(const BinID&,
                                          const SamplingData<float>&,
                                          int sz,float* res) const;
    float                       transformBack(const BinIDValue&) const;
    float                       transformBack(const Coord3&) const;
                                // 2D
    virtual void                transform2D(const char* linenm,int trcnr,
                                        const SamplingData<float>&,
                                        int sz,float* res) const;
    float                       transform2D(const char* linenm,int trcnr,
                                        float z) const;
    virtual void                transformBack2D(const char* linenm,int trcnr,
                                            const SamplingData<float>&,
                                            int sz,float* res) const;
    float                       transformBack2D(const char* linenm,int trcnr,
                                            float z) const;
};


mExpClass(Algo) ZAxisTransformSampler
{
public:
                                ZAxisTransformSampler(const ZAxisTransform&,
                                   bool back,const SamplingData<double>&,
                                   bool is2d);
    virtual                     ~ZAxisTransformSampler();

    void                        setBinID(const BinID& bid);
    void                        setTrcKey( const TrcKey& k ) { trckey_ = k ; }
    void                        setLineName(const char*);
    void                        setTrcNr(int);

    float                       operator[](int idx) const;
    void                        computeCache(const Interval<int>& range);

protected:

    const ZAxisTransform&       transform_;
    bool                        back_;
    bool                        is2d_;
    TrcKey                      trckey_;
    const SamplingData<double>  sd_;

    TypeSet<float>              cache_;
    int                         firstcachesample_;

};

#endif