Generated/html/zaxistransform_8h_source.html

#pragma once

/*+

________________________________________________________________________


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


};